<!doctype html><html lang="en">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
<meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
<title>Web IDL</title>
<link href="https://www.w3.org/StyleSheets/TR/W3C-ED" rel="stylesheet" type="text/css">
<style data-fill-with="stylesheet">/******************************************************************************
* Style sheet for the W3C specifications *
*
* Special classes handled by this style sheet include:
*
* Indices
* - .toc for the Table of Contents (<ol class="toc">)
* + <span class="secno"> for the section numbers
* - #toc for the Table of Contents (<nav id="toc">)
* - ul.index for Indices (<a href="#ref">term</a><span>, in §N.M</span>)
* - table.index for Index Tables (e.g. for properties or elements)
*
* Structural Markup
* - table.data for general data tables
* -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
* -> use <table class='complex data'> for extra-complex tables
* -> use <td class='long'> for paragraph-length cell content
* -> use <td class='pre'> when manual line breaks/indentation would help readability
* - dl.switch for switch statements
* - ol.algorithm for algorithms (helps to visualize nesting)
* - .figure and .caption (HTML4) and figure and figcaption (HTML5)
* -> .sidefigure for right-floated figures
* - ins/del
*
* Code
* - pre and code
*
* Special Sections
* - .note for informative notes (div, p, span, aside, details)
* - .example for informative examples (div, p, pre, span)
* - .issue for issues (div, p, span)
* - .assertion for assertions (div, p, span)
* - .advisement for loud normative statements (div, p, strong)
* - .annoying-warning for spec obsoletion notices (div, aside, details)
*
* Definition Boxes
* - pre.def for WebIDL definitions
* - table.def for tables that define other entities (e.g. CSS properties)
* - dl.def for definition lists that define other entitles (e.g. HTML elements)
*
* Numbering
* - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
* - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
* - ::before styled for CSS-generated issue/example/figure numbers:
* -> Documents wishing to use this only need to add
* figcaption::before,
* .caption::before { content: "Figure " counter(figure) " "; }
* .example::before { content: "Example " counter(example) " "; }
* .issue::before { content: "Issue " counter(issue) " "; }
*
* Header Stuff (ignore, just don't conflict with these classes)
* - .head for the header
* - .copyright for the copyright
*
* Miscellaneous
* - .overlarge for things that should be as wide as possible, even if
* that overflows the body text area. This can be used on an item or
* on its container, depending on the effect desired.
* Note that this styling basically doesn't help at all when printing,
* since A4 paper isn't much wider than the max-width here.
* It's better to design things to fit into a narrower measure if possible.
* - js-added ToC jump links (see fixup.js)
*
******************************************************************************/
/******************************************************************************/
/* Body */
/******************************************************************************/
body {
counter-reset: example figure issue;
/* Layout */
max-width: 50em; /* limit line length to 50em for readability */
margin: 0 auto; /* center text within page */
padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag */
/* Typography */
line-height: 1.5;
font-family: sans-serif;
widows: 2;
orphans: 2;
word-wrap: break-word;
overflow-wrap: break-word;
hyphens: auto;
/* Colors */
color: black;
background: white top left fixed no-repeat;
background-size: 25px auto;
}
/******************************************************************************/
/* Front Matter & Navigation */
/******************************************************************************/
/** Header ********************************************************************/
div.head { margin-bottom: 1em }
div.head hr { border-style: solid; }
div.head h1 {
font-weight: bold;
margin: 0 0 .1em;
font-size: 220%;
}
div.head h2 { margin-bottom: 1.5em;}
/** W3C Logo ******************************************************************/
.head .logo {
float: right;
margin: 0.4rem 0 0.2rem .4rem;
}
.head img[src*="logos/W3C"] {
display: block;
border: solid #1a5e9a;
border-width: .65rem .7rem .6rem;
border-radius: .4rem;
background: #1a5e9a;
color: white;
font-weight: bold;
}
.head a:hover > img[src*="logos/W3C"],
.head a:focus > img[src*="logos/W3C"] {
opacity: .8;
}
.head a:active > img[src*="logos/W3C"] {
background: #c00;
border-color: #c00;
}
/* see also additional rules in Link Styling section */
/** Copyright *****************************************************************/
p.copyright,
p.copyright small { font-size: small }
/** Back to Top / ToC Toggle **************************************************/
@media print {
#toc-nav {
display: none;
}
}
@media not print {
#toc-nav {
position: fixed;
z-index: 2;
bottom: 0; left: 0;
margin: 0;
min-width: 1.33em;
border-top-right-radius: 2rem;
box-shadow: 0 0 2px;
font-size: 1.5em;
color: black;
}
#toc-nav > a {
display: block;
white-space: nowrap;
height: 1.33em;
padding: .1em 0.3em;
margin: 0;
background: white;
box-shadow: 0 0 2px;
border: none;
border-top-right-radius: 1.33em;
background: white;
}
#toc-nav > #toc-jump {
padding-bottom: 2em;
margin-bottom: -1.9em;
}
#toc-nav > a:hover,
#toc-nav > a:focus {
background: #f8f8f8;
}
#toc-nav > a:not(:hover):not(:focus) {
color: #707070;
}
/* statusbar gets in the way on keyboard focus; remove once browsers fix */
#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
padding-bottom: 1.5rem;
}
#toc-nav:not(:hover) > a:not(:focus) > span + span {
/* Ideally this uses :focus-within on #toc-nav */
display: none;
}
#toc-nav > a > span + span {
padding-right: 0.2em;
}
#toc-toggle-inline {
vertical-align: 0.05em;
font-size: 80%;
color: gray;
color: hsla(203,20%,40%,.7);
border-style: none;
background: transparent;
position: relative;
}
#toc-toggle-inline:hover:not(:active),
#toc-toggle-inline:focus:not(:active) {
text-shadow: 1px 1px silver;
top: -1px;
left: -1px;
}
#toc-nav :active {
color: #C00;
}
}
/** ToC Sidebar ***************************************************************/
/* Floating sidebar */
@media screen {
body.toc-sidebar #toc {
position: fixed;
top: 0; bottom: 0;
left: 0;
width: 23.5em;
max-width: 80%;
max-width: calc(100% - 2em - 26px);
overflow: auto;
padding: 0 1em;
padding-left: 42px;
padding-left: calc(1em + 26px);
background: inherit;
background-color: #f7f8f9;
z-index: 1;
box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
}
body.toc-sidebar #toc h2 {
margin-top: .8rem;
font-variant: small-caps;
font-variant: all-small-caps;
text-transform: lowercase;
font-weight: bold;
color: gray;
color: hsla(203,20%,40%,.7);
}
body.toc-sidebar #toc-jump:not(:focus) {
width: 0;
height: 0;
padding: 0;
position: absolute;
overflow: hidden;
}
}
/* Hide main scroller when only the ToC is visible anyway */
@media screen and (max-width: 28em) {
body.toc-sidebar {
overflow: hidden;
}
}
/* Sidebar with its own space */
@media screen and (min-width: 78em) {
body:not(.toc-inline) #toc {
position: fixed;
top: 0; bottom: 0;
left: 0;
width: 23.5em;
overflow: auto;
padding: 0 1em;
padding-left: 42px;
padding-left: calc(1em + 26px);
background: inherit;
background-color: #f7f8f9;
z-index: 1;
box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
}
body:not(.toc-inline) #toc h2 {
margin-top: .8rem;
font-variant: small-caps;
font-variant: all-small-caps;
text-transform: lowercase;
font-weight: bold;
color: gray;
color: hsla(203,20%,40%,.7);
}
body:not(.toc-inline) {
padding-left: 29em;
}
/* See also Overflow section at the bottom */
body:not(.toc-inline) #toc-jump:not(:focus) {
width: 0;
height: 0;
padding: 0;
position: absolute;
overflow: hidden;
}
}
@media screen and (min-width: 90em) {
body:not(.toc-inline) {
margin: 0 4em;
}
}
/******************************************************************************/
/* Sectioning */
/******************************************************************************/
/** Headings ******************************************************************/
h1, h2, h3, h4, h5, h6, dt {
page-break-after: avoid;
page-break-inside: avoid;
font: 100% sans-serif; /* Reset all font styling to clear out UA styles */
font-family: inherit; /* Inherit the font family. */
line-height: 1.2; /* Keep wrapped headings compact */
hyphens: manual; /* Hyphenated headings look weird */
}
h2, h3, h4, h5, h6 {
margin-top: 3rem;
}
h1, h2, h3 {
color: #005A9C;
background: transparent;
}
h1 { font-size: 170%; }
h2 { font-size: 140%; }
h3 { font-size: 120%; }
h4 { font-weight: bold; }
h5 { font-style: italic; }
h6 { font-variant: small-caps; }
dt { font-weight: bold; }
/** Subheadings ***************************************************************/
h1 + h2,
#subtitle {
/* #subtitle is a subtitle in an H2 under the H1 */
margin-top: 0;
}
h2 + h3,
h3 + h4,
h4 + h5,
h5 + h6 {
margin-top: 1.2em; /* = 1 x line-height */
}
/** Section divider ***********************************************************/
:not(.head) > hr {
font-size: 1.5em;
text-align: center;
margin: 1em auto;
height: auto;
border: transparent solid 0;
background: transparent;
}
:not(.head) > hr::before {
content: "\2727\2003\2003\2727\2003\2003\2727";
}
/******************************************************************************/
/* Paragraphs and Lists */
/******************************************************************************/
p {
margin: 1em 0;
}
dd > p:first-child,
li > p:first-child {
margin-top: 0;
}
ul, ol {
margin-left: 0;
padding-left: 2em;
}
li {
margin: 0.25em 0 0.5em;
padding: 0;
}
dl dd {
margin: 0 0 .5em 2em;
}
.head dd + dd { /* compact for header */
margin-top: -.5em;
}
/* Style for algorithms */
ol.algorithm ol:not(.algorithm),
.algorithm > ol ol:not(.algorithm) {
border-left: 0.5em solid #DEF;
}
/* Put nice boxes around each algorithm. */
[data-algorithm]:not(.heading) {
padding: .5em;
border: thin solid #ddd; border-radius: .5em;
margin: .5em 0;
}
[data-algorithm]:not(.heading) > :first-child {
margin-top: 0;
}
[data-algorithm]:not(.heading) > :last-child {
margin-bottom: 0;
}
/* Style for switch/case <dl>s */
dl.switch > dd > ol.only,
dl.switch > dd > .only > ol {
margin-left: 0;
}
dl.switch > dd > ol.algorithm,
dl.switch > dd > .algorithm > ol {
margin-left: -2em;
}
dl.switch {
padding-left: 2em;
}
dl.switch > dt {
text-indent: -1.5em;
margin-top: 1em;
}
dl.switch > dt + dt {
margin-top: 0;
}
dl.switch > dt::before {
content: '\21AA';
padding: 0 0.5em 0 0;
display: inline-block;
width: 1em;
text-align: right;
line-height: 0.5em;
}
/** Terminology Markup ********************************************************/
/******************************************************************************/
/* Inline Markup */
/******************************************************************************/
/** Terminology Markup ********************************************************/
dfn { /* Defining instance */
font-weight: bolder;
}
a > i { /* Instance of term */
font-style: normal;
}
dt dfn code, code.idl {
font-size: normal;
}
dfn var {
font-style: normal;
}
/** Change Marking ************************************************************/
del { color: red; text-decoration: line-through; }
ins { color: #080; text-decoration: underline; }
/** Miscellaneous improvements to inline formatting ***************************/
sup {
vertical-align: super;
font-size: 80%
}
/******************************************************************************/
/* Code */
/******************************************************************************/
/** General monospace/pre rules ***********************************************/
pre, code, samp {
font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
font-size: .9em;
page-break-inside: avoid;
hyphens: none;
text-transform: none;
}
pre code,
code code {
font-size: 100%;
}
pre {
margin-top: 1em;
margin-bottom: 1em;
overflow: auto;
}
/** Inline Code fragments *****************************************************/
/* Do something nice. */
/******************************************************************************/
/* Links */
/******************************************************************************/
/** General Hyperlinks ********************************************************/
/* We hyperlink a lot, so make it less intrusive */
a[href] {
color: #034575;
text-decoration: none;
border-bottom: 1px solid #707070;
/* Need a bit of extending for it to look okay */
padding: 0 1px 0;
margin: 0 -1px 0;
}
a:visited {
border-bottom-color: #BBB;
}
/* Use distinguishing colors when user is interacting with the link */
a[href]:focus,
a[href]:hover {
background: #f8f8f8;
background: rgba(75%, 75%, 75%, .25);
border-bottom-width: 3px;
margin-bottom: -2px;
}
a[href]:active {
color: #C00;
border-color: #C00;
}
/* Backout above styling for W3C logo */
.head .logo,
.head .logo a {
border: none;
text-decoration: none;
background: transparent;
}
/******************************************************************************/
/* Images */
/******************************************************************************/
img {
border-style: none;
}
/* For autogen numbers, add
.caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
*/
figure, .figure, .sidefigure {
page-break-inside: avoid;
text-align: center;
margin: 2.5em 0;
}
.figure img, .sidefigure img, figure img,
.figure object, .sidefigure object, figure object {
max-width: 100%;
margin: auto;
}
.figure pre, .sidefigure pre, figure pre {
text-align: left;
display: table;
margin: 1em auto;
}
.figure table, figure table {
margin: auto;
}
@media screen and (min-width: 20em) {
.sidefigure {
float: right;
width: 50%;
margin: 0 0 0.5em 0.5em
}
}
.caption, figcaption, caption {
font-style: italic;
font-size: 90%;
}
.caption::before, figcaption::before, figcaption > .marker {
font-weight: bold;
}
.caption, figcaption {
counter-increment: figure;
}
/* DL list is indented 2em, but figure inside it is not */
dd > .figure, dd > figure { margin-left: -2em }
/******************************************************************************/
/* Colored Boxes */
/******************************************************************************/
.issue, .note, .example, .assertion, .advisement, blockquote {
padding: .5em;
border: .5em;
border-left-style: solid;
page-break-inside: avoid;
}
span.issue, span.note {
padding: .1em .5em .15em;
border-right-style: solid;
}
.issue,
.note,
.example,
.advisement,
.assertion,
blockquote {
margin: 1em auto;
}
.note > p:first-child,
.issue > p:first-child,
blockquote > :first-child {
margin-top: 0;
}
blockquote > :last-child {
margin-bottom: 0;
}
/** Blockquotes ***************************************************************/
blockquote {
border-color: silver;
}
/** Open issue ****************************************************************/
.issue {
border-color: #E05252;
background: #FBE9E9;
counter-increment: issue;
overflow: auto;
}
.issue::before, .issue > .marker {
text-transform: uppercase;
color: #AE1E1E;
padding-right: 1em;
text-transform: uppercase;
}
/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
or use class="marker" to mark up the issue number in source. */
/** Example *******************************************************************/
.example {
border-color: #E0CB52;
background: #FCFAEE;
counter-increment: example;
overflow: auto;
clear: both;
}
.example::before, .example > .marker {
text-transform: uppercase;
color: #827017;
min-width: 7.5em;
display: block;
}
/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
or use class="marker" to mark up the example number in source. */
/** Non-normative Note ********************************************************/
.note {
border-color: #52E052;
background: #E9FBE9;
overflow: auto;
}
.note::before, .note > .marker,
details.note > summary::before,
details.note > summary > .marker {
text-transform: uppercase;
display: block;
color: hsl(120, 70%, 30%);
}
/* Add .note::before { content: "Note"; } for autogen label,
or use class="marker" to mark up the label in source. */
details.note > summary {
display: block;
color: hsl(120, 70%, 30%);
}
details.note[open] > summary {
border-bottom: 1px silver solid;
}
/** Assertion Box *************************************************************/
/* for assertions in algorithms */
.assertion {
border-color: #AAA;
background: #EEE;
}
/** Advisement Box ************************************************************/
/* for attention-grabbing normative statements */
.advisement {
border-color: orange;
border-style: none solid;
background: #FFEECC;
}
strong.advisement {
display: block;
text-align: center;
}
.advisement > .marker {
color: #B35F00;
}
/** Spec Obsoletion Notice ****************************************************/
/* obnoxious obsoletion notice for older/abandoned specs. */
details {
display: block;
}
summary {
font-weight: bolder;
}
.annoying-warning:not(details),
details.annoying-warning:not([open]) > summary,
details.annoying-warning[open] {
background: #fdd;
color: red;
font-weight: bold;
padding: .75em 1em;
border: thick red;
border-style: solid;
border-radius: 1em;
}
.annoying-warning :last-child {
margin-bottom: 0;
}
@media not print {
details.annoying-warning[open] {
position: fixed;
left: 1em;
right: 1em;
bottom: 1em;
z-index: 1000;
}
}
details.annoying-warning:not([open]) > summary {
text-align: center;
}
/** Entity Definition Boxes ***************************************************/
.def {
padding: .5em 1em;
background: #DEF;
margin: 1.2em 0;
border-left: 0.5em solid #8CCBF2;
}
/******************************************************************************/
/* Tables */
/******************************************************************************/
th, td {
text-align: left;
text-align: start;
}
/** Property/Descriptor Definition Tables *************************************/
table.def {
/* inherits .def box styling, see above */
width: 100%;
border-spacing: 0;
}
table.def td,
table.def th {
padding: 0.5em;
vertical-align: baseline;
border-bottom: 1px solid #bbd7e9;
}
table.def > tbody > tr:last-child th,
table.def > tbody > tr:last-child td {
border-bottom: 0;
}
table.def th {
font-style: italic;
font-weight: normal;
padding-left: 1em;
width: 3em;
}
/* For when values are extra-complex and need formatting for readability */
table td.pre {
white-space: pre-wrap;
}
/* A footnote at the bottom of a def table */
table.def td.footnote {
padding-top: 0.6em;
}
table.def td.footnote::before {
content: " ";
display: block;
height: 0.6em;
width: 4em;
border-top: thin solid;
}
/** Data tables (and properly marked-up index tables) *************************/
/*
<table class="data"> highlights structural relationships in a table
when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)
Use class="complex data" for particularly complicated tables --
(This will draw more lines: busier, but clearer.)
Use class="long" on table cells with paragraph-like contents
(This will adjust text alignment accordingly.)
Alternately use class="longlastcol" on tables, to have the last column assume "long".
*/
table {
word-wrap: normal;
overflow-wrap: normal;
hyphens: manual;
}
table.data,
table.index {
margin: 1em auto;
border-collapse: collapse;
border: hidden;
width: 100%;
}
table.data caption,
table.index caption {
max-width: 50em;
margin: 0 auto 1em;
}
table.data td, table.data th,
table.index td, table.index th {
padding: 0.5em 1em;
border-width: 1px;
border-color: silver;
border-top-style: solid;
}
table.data thead td:empty {
padding: 0;
border: 0;
}
table.data thead,
table.index thead,
table.data tbody,
table.index tbody {
border-bottom: 2px solid;
}
table.data colgroup,
table.index colgroup {
border-left: 2px solid;
}
table.data tbody th:first-child,
table.index tbody th:first-child {
border-right: 2px solid;
border-top: 1px solid silver;
padding-right: 1em;
}
table.data th[colspan],
table.data td[colspan] {
text-align: center;
}
table.complex.data th,
table.complex.data td {
border: 1px solid silver;
text-align: center;
}
table.data.longlastcol td:last-child,
table.data td.long {
vertical-align: baseline;
text-align: left;
}
table.data img {
vertical-align: middle;
}
/*
Alternate table alignment rules
table.data,
table.index {
text-align: center;
}
table.data thead th[scope="row"],
table.index thead th[scope="row"] {
text-align: right;
}
table.data tbody th:first-child,
table.index tbody th:first-child {
text-align: right;
}
Possible extra rowspan handling
table.data tbody th[rowspan]:not([rowspan='1']),
table.index tbody th[rowspan]:not([rowspan='1']),
table.data tbody td[rowspan]:not([rowspan='1']),
table.index tbody td[rowspan]:not([rowspan='1']) {
border-left: 1px solid silver;
}
table.data tbody th[rowspan]:first-child,
table.index tbody th[rowspan]:first-child,
table.data tbody td[rowspan]:first-child,
table.index tbody td[rowspan]:first-child{
border-left: 0;
border-right: 1px solid silver;
}
*/
/******************************************************************************/
/* Indices */
/******************************************************************************/
/** Table of Contents *********************************************************/
.toc a {
/* More spacing; use padding to make it part of the click target. */
padding-top: 0.1rem;
/* Larger, more consistently-sized click target */
display: block;
/* Reverse color scheme */
color: black;
border-color: #3980B5;
}
.toc a:visited {
border-color: #054572;
}
.toc a:not(:focus):not(:hover) {
/* Allow colors to cascade through from link styling */
border-bottom-color: transparent;
}
.toc, .toc ol, .toc ul, .toc li {
list-style: none; /* Numbers must be inlined into source */
/* because generated content isn't search/selectable and markers can't do multilevel yet */
margin: 0;
padding: 0;
line-height: 1.1rem; /* consistent spacing */
}
/* ToC not indented until third level, but font style & margins show hierarchy */
.toc > li { font-weight: bold; }
.toc > li li { font-weight: normal; }
.toc > li li li { font-size: 95%; }
.toc > li li li li { font-size: 90%; }
.toc > li li li li li { font-size: 85%; }
.toc > li { margin: 1.5rem 0; }
.toc > li li { margin: 0.3rem 0; }
.toc > li li li { margin-left: 2rem; }
/* Section numbers in a column of their own */
.toc .secno {
float: left;
width: 4rem;
white-space: nowrap;
}
.toc > li li li li .secno {
font-size: 85%;
}
.toc > li li li li li .secno {
font-size: 100%;
}
:not(li) > .toc { margin-left: 5rem; }
.toc .secno { margin-left: -5rem; }
.toc > li li li .secno { margin-left: -7rem; }
.toc > li li li li .secno { margin-left: -9rem; }
.toc > li li li li li .secno { margin-left: -11rem; }
/* Tighten up indentation in narrow ToCs */
@media (max-width: 30em) {
:not(li) > .toc { margin-left: 4rem; }
.toc .secno { margin-left: -4rem; }
.toc > li li li { margin-left: 1rem; }
.toc > li li li .secno { margin-left: -5rem; }
.toc > li li li li .secno { margin-left: -6rem; }
.toc > li li li li li .secno { margin-left: -7rem; }
}
@media screen and (min-width: 78em) {
body:not(.toc-inline) :not(li) > .toc { margin-left: 4rem; }
body:not(.toc-inline) .toc .secno { margin-left: -4rem; }
body:not(.toc-inline) .toc > li li li { margin-left: 1rem; }
body:not(.toc-inline) .toc > li li li .secno { margin-left: -5rem; }
body:not(.toc-inline) .toc > li li li li .secno { margin-left: -6rem; }
body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
}
body.toc-sidebar #toc :not(li) > .toc { margin-left: 4rem; }
body.toc-sidebar #toc .toc .secno { margin-left: -4rem; }
body.toc-sidebar #toc .toc > li li li { margin-left: 1rem; }
body.toc-sidebar #toc .toc > li li li .secno { margin-left: -5rem; }
body.toc-sidebar #toc .toc > li li li li .secno { margin-left: -6rem; }
body.toc-sidebar #toc .toc > li li li li li .secno { margin-left: -7rem; }
.toc li {
clear: both;
}
/** Index *********************************************************************/
/* Index Lists: Layout */
ul.index { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
ul.index li { margin-left: 0; list-style: none; break-inside: avoid; }
ul.index li li { margin-left: 1em }
ul.index dl { margin-top: 0; }
ul.index dt { margin: .2em 0 .2em 20px;}
ul.index dd { margin: .2em 0 .2em 40px;}
/* Index Lists: Typography */
ul.index ul,
ul.index dl { font-size: smaller; }
@media not print {
ul.index li span {
white-space: nowrap;
color: transparent; }
ul.index li a:hover + span,
ul.index li a:focus + span {
color: #707070;
}
}
/** Index Tables *****************************************************/
/* See also the data table styling section, which this effectively subclasses */
table.index {
font-size: small;
border-collapse: collapse;
border-spacing: 0;
text-align: left;
margin: 1em 0;
}
table.index td,
table.index th {
padding: 0.4em;
}
table.index tr:hover td:not([rowspan]),
table.index tr:hover th:not([rowspan]) {
background: #f7f8f9;
}
/* The link in the first column in the property table (formerly a TD) */
table.index th:first-child a {
font-weight: bold;
}
/******************************************************************************/
/* Print */
/******************************************************************************/
@media print {
/* Pages have their own margins. */
html {
margin: 0;
}
/* Serif for print. */
body {
font-family: serif;
}
}
@page {
margin: 1.5cm 1.1cm;
}
/******************************************************************************/
/* Legacy */
/******************************************************************************/
/* This rule is inherited from past style sheets. No idea what it's for. */
.hide { display: none }
/******************************************************************************/
/* Overflow Control */
/******************************************************************************/
.figure .caption, .sidefigure .caption, figcaption {
/* in case figure is overlarge, limit caption to 50em */
max-width: 50rem;
margin-left: auto;
margin-right: auto;
}
.overlarge > table {
/* limit preferred width of table */
max-width: 50em;
margin-left: auto;
margin-right: auto;
}
@media (min-width: 55em) {
.overlarge {
margin-left: calc(13px + 26.5rem - 50vw);
margin-right: calc(13px + 26.5rem - 50vw);
max-width: none;
}
}
@media screen and (min-width: 78em) {
body:not(.toc-inline) .overlarge {
/* 30.5em body padding 50em content area */
margin-left: calc(40em - 50vw) !important;
margin-right: calc(40em - 50vw) !important;
}
}
@media screen and (min-width: 90em) {
body:not(.toc-inline) .overlarge {
/* 4em html margin 30.5em body padding 50em content area */
margin-left: 0 !important;
margin-right: calc(84.5em - 100vw) !important;
}
}
@media not print {
.overlarge {
overflow-x: auto;
/* See Lea Verou's explanation background-attachment:
* http://lea.verou.me/2012/04/background-attachment-local/
*
background: top left / 4em 100% linear-gradient(to right, #ffffff, rgba(255, 255, 255, 0)) local,
top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
top left / 1em 100% linear-gradient(to right, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
white;
background-repeat: no-repeat;
*/
}
}
</style>
<meta content="Bikeshed 1.0.0" name="generator">
<style>
pre.set {
font-size: 80%;
}
.syntax .n,
.syntax .nv {
font-style: italic;
}
.mute {
color: #9D937D
}
emu-val {
font-weight: bold;
}
emu-nt {
font-family: sans-serif;
font-style: italic;
white-space: nowrap;
}
emu-t {
font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
display: inline-block;
font-weight: bold;
white-space: nowrap;
}
emu-t.symbol {
font-family: sans-serif;
font-weight: bold;
}
emu-t a[href],
emu-nt a[href] {
color: inherit;
border-bottom: 1px solid transparent;
}
emu-t a[href]:focus,
emu-nt a[href]:focus,
emu-t a[href]:hover,
emu-nt a[href]:hover {
background: #f8f8f8;
background: rgba(75%, 75%, 75%, .25);
border-bottom: 3px solid #707070;
margin-bottom: -2px;
}
/* start bug fix, see: https://github.com/tobie/webidl/issues/24 */
pre.grammar {
padding-bottom: 1px
}
/* end bug fix */
dt p {
display: inline;
}
.char {
font-size: 85%
}
#distinguishable-table {
font-size: 80%;
border-collapse: collapse;
}
#distinguishable-table th {
text-align: right;
}
#distinguishable-table tr:first-child th {
white-space: nowrap;
text-align: center;
}
#distinguishable-table .belowdiagonal {
background: #ddd;
}
#distinguishable-table td {
text-align: center;
padding: 5px 10px;
}
.csstransforms #distinguishable-table tr:first-child th {
text-align: left;
border: none;
height: 100px;
padding: 0;
}
.csstransforms #distinguishable-table td {
text-align: center;
width: 30px;
padding: 10px 5px;
height: 19px
}
/* Firefox needs the extra DIV for some reason, otherwise the text disappears if you rotate */
.csstransforms #distinguishable-table tr:first-child th div {
-webkit-transform: translate(26px, 31px) rotate(315deg);
transform: translate(26px, 31px) rotate(315deg);
width: 30px;
}
.csstransforms #distinguishable-table tr:first-child th div span {
border-bottom: 1px solid #ccc;
padding: 5px 10px;
display: block;
min-width: 120px;
text-align: left
}
.csstransforms #distinguishable-table tr:first-child th:last-child div span {
border-bottom: none;
}
</style>
<style>/* style-md-lists */
/* This is a weird hack for me not yet following the commonmark spec
regarding paragraph and lists. */
[data-md] > :first-child {
margin-top: 0;
}
[data-md] > :last-child {
margin-bottom: 0;
}</style>
<style>/* style-selflinks */
.heading, .issue, .note, .example, li, dt {
position: relative;
}
a.self-link {
position: absolute;
top: 0;
left: calc(-1 * (3.5rem - 26px));
width: calc(3.5rem - 26px);
height: 2em;
text-align: center;
border: none;
transition: opacity .2s;
opacity: .5;
}
a.self-link:hover {
opacity: 1;
}
.heading > a.self-link {
font-size: 83%;
}
li > a.self-link {
left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
top: auto;
left: auto;
opacity: 0;
width: 1.5em;
height: 1.5em;
background: gray;
color: white;
font-style: normal;
transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
opacity: 1;
}
dfn > a.self-link:hover {
color: black;
}
a.self-link::before { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before { content: "#"; }</style>
<style>/* style-counters */
body {
counter-reset: example figure issue;
}
.issue {
counter-increment: issue;
}
.issue:not(.no-marker)::before {
content: "Issue " counter(issue);
}
.example {
counter-increment: example;
}
.example:not(.no-marker)::before {
content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
content: "Invalid Example" counter(example);
}
figcaption {
counter-increment: figure;
}
figcaption:not(.no-marker)::before {
content: "Figure " counter(figure) " ";
}</style>
<style>/* style-autolinks */
.css.css, .property.property, .descriptor.descriptor {
color: #005a9c;
font-size: inherit;
font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
content: "‘";
}
.css::after, .property::after, .descriptor::after {
content: "’";
}
.property, .descriptor {
/* Don't wrap property and descriptor names */
white-space: nowrap;
}
.type { /* CSS value <type> */
font-style: italic;
}
pre .property::before, pre .property::after {
content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
content: "’";
}
[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
content: "";
}
[data-link-type=element],
[data-link-type=element-attr] {
font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after { content: ">" }
[data-link-type=biblio] {
white-space: pre;
}</style>
<style>/* style-dfn-panel */
.dfn-panel {
position: absolute;
z-index: 35;
height: auto;
width: -webkit-fit-content;
width: fit-content;
max-width: 300px;
max-height: 500px;
overflow: auto;
padding: 0.5em 0.75em;
font: small Helvetica Neue, sans-serif, Droid Sans Fallback;
background: #DDDDDD;
color: black;
border: outset 0.2em;
}
.dfn-panel:not(.on) { display: none; }
.dfn-panel * { margin: 0; padding: 0; text-indent: 0; }
.dfn-panel > b { display: block; }
.dfn-panel a { color: black; }
.dfn-panel a:not(:hover) { text-decoration: none !important; border-bottom: none !important; }
.dfn-panel > b + b { margin-top: 0.25em; }
.dfn-panel ul { padding: 0; }
.dfn-panel li { list-style: inside; }
.dfn-panel.activated {
display: inline-block;
position: fixed;
left: .5em;
bottom: 2em;
margin: 0 auto;
max-width: calc(100vw - 1.5em - .4em - .5em);
max-height: 30vh;
}
.dfn-paneled { cursor: pointer; }
</style>
<style>/* style-syntax-highlighting */
pre.idl.highlight { color: #708090; }
.highlight:not(.idl) { background: hsl(24, 20%, 95%); }
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }
.highlight .c { color: #708090 } /* Comment */
.highlight .k { color: #990055 } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #0077aa } /* Name */
.highlight .o { color: #999999 } /* Operator */
.highlight .p { color: #999999 } /* Punctuation */
.highlight .cm { color: #708090 } /* Comment.Multiline */
.highlight .cp { color: #708090 } /* Comment.Preproc */
.highlight .c1 { color: #708090 } /* Comment.Single */
.highlight .cs { color: #708090 } /* Comment.Special */
.highlight .kc { color: #990055 } /* Keyword.Constant */
.highlight .kd { color: #990055 } /* Keyword.Declaration */
.highlight .kn { color: #990055 } /* Keyword.Namespace */
.highlight .kp { color: #990055 } /* Keyword.Pseudo */
.highlight .kr { color: #990055 } /* Keyword.Reserved */
.highlight .kt { color: #990055 } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #000000 } /* Literal.Number */
.highlight .s { color: #a67f59 } /* Literal.String */
.highlight .na { color: #0077aa } /* Name.Attribute */
.highlight .nc { color: #0077aa } /* Name.Class */
.highlight .no { color: #0077aa } /* Name.Constant */
.highlight .nd { color: #0077aa } /* Name.Decorator */
.highlight .ni { color: #0077aa } /* Name.Entity */
.highlight .ne { color: #0077aa } /* Name.Exception */
.highlight .nf { color: #0077aa } /* Name.Function */
.highlight .nl { color: #0077aa } /* Name.Label */
.highlight .nn { color: #0077aa } /* Name.Namespace */
.highlight .py { color: #0077aa } /* Name.Property */
.highlight .nt { color: #669900 } /* Name.Tag */
.highlight .nv { color: #222222 } /* Name.Variable */
.highlight .ow { color: #999999 } /* Operator.Word */
.highlight .mb { color: #000000 } /* Literal.Number.Bin */
.highlight .mf { color: #000000 } /* Literal.Number.Float */
.highlight .mh { color: #000000 } /* Literal.Number.Hex */
.highlight .mi { color: #000000 } /* Literal.Number.Integer */
.highlight .mo { color: #000000 } /* Literal.Number.Oct */
.highlight .sb { color: #a67f59 } /* Literal.String.Backtick */
.highlight .sc { color: #a67f59 } /* Literal.String.Char */
.highlight .sd { color: #a67f59 } /* Literal.String.Doc */
.highlight .s2 { color: #a67f59 } /* Literal.String.Double */
.highlight .se { color: #a67f59 } /* Literal.String.Escape */
.highlight .sh { color: #a67f59 } /* Literal.String.Heredoc */
.highlight .si { color: #a67f59 } /* Literal.String.Interpol */
.highlight .sx { color: #a67f59 } /* Literal.String.Other */
.highlight .sr { color: #a67f59 } /* Literal.String.Regex */
.highlight .s1 { color: #a67f59 } /* Literal.String.Single */
.highlight .ss { color: #a67f59 } /* Literal.String.Symbol */
.highlight .vc { color: #0077aa } /* Name.Variable.Class */
.highlight .vg { color: #0077aa } /* Name.Variable.Global */
.highlight .vi { color: #0077aa } /* Name.Variable.Instance */
.highlight .il { color: #000000 } /* Literal.Number.Integer.Long */
</style>
<body class="h-entry">
<div class="head">
<p data-fill-with="logo"><a class="logo" href="http://www.w3.org/"> <img alt="W3C" height="48" src="https://www.w3.org/StyleSheets/TR/2016/logos/W3C" width="72"> </a> </p>
<h1 class="p-name no-ref" id="title">Web IDL</h1>
<h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Editor’s Draft, <time class="dt-updated" datetime="2016-09-30">30 September 2016</time></span></h2>
<div data-fill-with="spec-metadata">
<dl>
<dt>This version:
<dd><a class="u-url" href="https://heycam.github.io/webidl/">https://heycam.github.io/webidl/</a>
<dt>Feedback:
<dd><span><a href="mailto:public-script-coord@w3.org?subject=%5BWebIDL%5D%20YOUR%20TOPIC%20HERE">public-script-coord@w3.org</a> with subject line “<kbd>[WebIDL] <i data-lt="">… message topic …</i></kbd>” (<a href="https://lists.w3.org/Archives/Public/public-script-coord/" rel="discussion">archives</a>)</span>
<dd><span><a href="https://github.com/heycam/webidl">GitHub</a> (<a href="https://github.com/heycam/webidl/issues/new">new issue</a>, <a href="https://github.com/heycam/webidl/issues">open issues</a>, <a href="https://www.w3.org/Bugs/Public/buglist.cgi?product=WebAppsWG&component=WebIDL&resolution=---">legacy bug tracker</a>)</span>
<dt class="editor">Editors:
<dd class="editor p-author h-card vcard"><a class="p-name fn u-url url" href="http://mcc.id.au/">Cameron McCormack</a> (<span class="p-org org">Mozilla Corporation</span>) <a class="u-email email" href="mailto:cam@mcc.id.au">cam@mcc.id.au</a>
<dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:bzbarsky@mit.edu">Boris Zbarsky</a> (<span class="p-org org">Mozilla Corporation</span>)
</dl>
</div>
<div data-fill-with="warning"></div>
<p class="copyright" data-fill-with="copyright"><a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © 2016 <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document" rel="license">permissive document license</a> rules apply. </p>
<hr title="Separator for header">
</div>
<h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
<div class="p-summary" data-fill-with="abstract">
<p>This document defines an interface definition language, Web IDL,
that can be used to describe interfaces that are intended to be
implemented in web browsers. Web IDL is an IDL variant with a
number of features that allow the behavior of common script objects in
the web platform to be specified more readily. How interfaces
described with Web IDL correspond to constructs within ECMAScript
execution environments is also detailed in this document.
It is expected that this document acts
as a guide to implementors of already-published specifications,
and that newly published specifications reference this
document to ensure conforming implementations of interfaces
are interoperable.</p>
</div>
<h2 class="no-num no-toc no-ref heading settled" id="status"><span class="content">Status of this document</span></h2>
<div data-fill-with="status">
<p> This is a public copy of the editors’ draft.
It is provided for discussion only and may change at any moment.
Its publication here does not imply endorsement of its contents by W3C.
Don’t cite this document other than as work in progress. </p>
<p> <strong>Changes to this document may be tracked at <a href="https://github.com/heycam/webidl">https://github.com/heycam/webidl</a>.</strong> </p>
<p> If you wish to make comments regarding this document, please send them to this specification’s <a href="https://github.com/heycam/webidl">GitHub repository</a> or (<a href="https://lists.w3.org/Archives/Public/public-script-coord/">archived</a>) public mailing list <a href="mailto:public-script-coord@w3.org?Subject=%5BWebIDL%5D%20PUT%20SUBJECT%20HERE">public-script-coord@w3.org</a> (see <a href="http://www.w3.org/Mail/Request">instructions</a>). When sending e-mail, please put the text “WebIDL” in the subject, preferably like this: “[WebIDL] <em>…summary of comment…</em>. All comments are welcome. </p>
<p> This document was produced by the <a href="https://www.w3.org/WebPlatform/WG/">Web Platform Working Group</a>. </p>
<p> This document was produced by a group operating under
the <a href="https://www.w3.org/Consortium/Patent-Policy-20040205/">5 February 2004 W3C Patent Policy</a>.
W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/83482/status" rel="disclosure">public list of any patent disclosures</a> made in connection with the deliverables of the group;
that page also includes instructions for disclosing a patent.
An individual who has actual knowledge of a patent which the individual believes contains <a href="https://www.w3.org/Consortium/Patent-Policy-20040205/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy-20040205/#sec-Disclosure">section 6 of the W3C Patent Policy</a>. </p>
<p> This document is governed by the <a href="https://www.w3.org/2015/Process-20150901/" id="w3c_process_revision">1 September 2015 W3C Process Document</a>. </p>
<p></p>
</div>
<div data-fill-with="at-risk"></div>
<nav data-fill-with="table-of-contents" id="toc">
<h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
<ol class="toc" role="directory">
<li><a href="#introduction"><span class="secno">1</span> <span class="content">Introduction</span></a>
<li>
<a href="#idl"><span class="secno">2</span> <span class="content">Interface definition language</span></a>
<ol class="toc">
<li><a href="#idl-names"><span class="secno">2.1</span> <span class="content">Names</span></a>
<li>
<a href="#idl-interfaces"><span class="secno">2.2</span> <span class="content">Interfaces</span></a>
<ol class="toc">
<li><a href="#idl-constants"><span class="secno">2.2.1</span> <span class="content">Constants</span></a>
<li><a href="#idl-attributes"><span class="secno">2.2.2</span> <span class="content">Attributes</span></a>
<li><a href="#idl-operations"><span class="secno">2.2.3</span> <span class="content">Operations</span></a>
<li>
<a href="#idl-special-operations"><span class="secno">2.2.4</span> <span class="content">Special operations</span></a>
<ol class="toc">
<li><a href="#idl-legacy-callers"><span class="secno">2.2.4.1</span> <span class="content">Legacy callers</span></a>
<li><a href="#idl-stringifiers"><span class="secno">2.2.4.2</span> <span class="content">Stringifiers</span></a>
<li><a href="#idl-serializers"><span class="secno">2.2.4.3</span> <span class="content">Serializers</span></a>
<li><a href="#idl-indexed-properties"><span class="secno">2.2.4.4</span> <span class="content">Indexed properties</span></a>
<li><a href="#idl-named-properties"><span class="secno">2.2.4.5</span> <span class="content">Named properties</span></a>
</ol>
<li><a href="#idl-static-attributes-and-operations"><span class="secno">2.2.5</span> <span class="content">Static attributes and operations</span></a>
<li><a href="#idl-overloading"><span class="secno">2.2.6</span> <span class="content">Overloading</span></a>
<li><a href="#idl-iterable"><span class="secno">2.2.7</span> <span class="content">Iterable declarations</span></a>
<li><a href="#idl-maplike"><span class="secno">2.2.8</span> <span class="content">Maplike declarations</span></a>
<li><a href="#idl-setlike"><span class="secno">2.2.9</span> <span class="content">Setlike declarations</span></a>
</ol>
<li><a href="#idl-namespaces"><span class="secno">2.3</span> <span class="content">Namespaces</span></a>
<li><a href="#idl-dictionaries"><span class="secno">2.4</span> <span class="content">Dictionaries</span></a>
<li>
<a href="#idl-exceptions"><span class="secno">2.5</span> <span class="content">Exceptions</span></a>
<ol class="toc">
<li><a href="#idl-DOMException-error-names"><span class="secno">2.5.1</span> <span class="content">Error names</span></a>
</ol>
<li><a href="#idl-enums"><span class="secno">2.6</span> <span class="content">Enumerations</span></a>
<li><a href="#idl-callback-functions"><span class="secno">2.7</span> <span class="content">Callback functions</span></a>
<li><a href="#idl-typedefs"><span class="secno">2.8</span> <span class="content">Typedefs</span></a>
<li><a href="#idl-implements-statements"><span class="secno">2.9</span> <span class="content">Implements statements</span></a>
<li><a href="#idl-objects"><span class="secno">2.10</span> <span class="content">Objects implementing interfaces</span></a>
<li>
<a href="#idl-types"><span class="secno">2.11</span> <span class="content">Types</span></a>
<ol class="toc">
<li><a href="#idl-any"><span class="secno">2.11.1</span> <span class="content">any</span></a>
<li><a href="#idl-boolean"><span class="secno">2.11.2</span> <span class="content">boolean</span></a>
<li><a href="#idl-byte"><span class="secno">2.11.3</span> <span class="content">byte</span></a>
<li><a href="#idl-octet"><span class="secno">2.11.4</span> <span class="content">octet</span></a>
<li><a href="#idl-short"><span class="secno">2.11.5</span> <span class="content">short</span></a>
<li><a href="#idl-unsigned-short"><span class="secno">2.11.6</span> <span class="content">unsigned short</span></a>
<li><a href="#idl-long"><span class="secno">2.11.7</span> <span class="content">long</span></a>
<li><a href="#idl-unsigned-long"><span class="secno">2.11.8</span> <span class="content">unsigned long</span></a>
<li><a href="#idl-long-long"><span class="secno">2.11.9</span> <span class="content">long long</span></a>
<li><a href="#idl-unsigned-long-long"><span class="secno">2.11.10</span> <span class="content">unsigned long long</span></a>
<li><a href="#idl-float"><span class="secno">2.11.11</span> <span class="content">float</span></a>
<li><a href="#idl-unrestricted-float"><span class="secno">2.11.12</span> <span class="content">unrestricted float</span></a>
<li><a href="#idl-double"><span class="secno">2.11.13</span> <span class="content">double</span></a>
<li><a href="#idl-unrestricted-double"><span class="secno">2.11.14</span> <span class="content">unrestricted double</span></a>
<li><a href="#idl-DOMString"><span class="secno">2.11.15</span> <span class="content">DOMString</span></a>
<li><a href="#idl-ByteString"><span class="secno">2.11.16</span> <span class="content">ByteString</span></a>
<li><a href="#idl-USVString"><span class="secno">2.11.17</span> <span class="content">USVString</span></a>
<li><a href="#idl-object"><span class="secno">2.11.18</span> <span class="content">object</span></a>
<li><a href="#idl-interface"><span class="secno">2.11.19</span> <span class="content">Interface types</span></a>
<li><a href="#idl-dictionary"><span class="secno">2.11.20</span> <span class="content">Dictionary types</span></a>
<li><a href="#idl-enumeration"><span class="secno">2.11.21</span> <span class="content">Enumeration types</span></a>
<li><a href="#idl-callback-function"><span class="secno">2.11.22</span> <span class="content">Callback function types</span></a>
<li><a href="#idl-nullable-type"><span class="secno">2.11.23</span> <span class="content">Nullable types — <var>T</var>?</span></a>
<li><a href="#idl-sequence"><span class="secno">2.11.24</span> <span class="content">Sequence types — sequence<<var>T</var>></span></a>
<li><a href="#idl-open-dictionary"><span class="secno">2.11.25</span> <span class="content">Open dictionary types — OpenDictionary<[<var>K</var>,] <var>V</var>></span></a>
<li><a href="#idl-promise"><span class="secno">2.11.26</span> <span class="content">Promise types — Promise<<var>T</var>></span></a>
<li><a href="#idl-union"><span class="secno">2.11.27</span> <span class="content">Union types</span></a>
<li><a href="#idl-RegExp"><span class="secno">2.11.28</span> <span class="content">RegExp</span></a>
<li><a href="#idl-Error"><span class="secno">2.11.29</span> <span class="content">Error</span></a>
<li><a href="#idl-DOMException"><span class="secno">2.11.30</span> <span class="content">DOMException</span></a>
<li><a href="#idl-buffer-source-types"><span class="secno">2.11.31</span> <span class="content">Buffer source types</span></a>
<li><a href="#idl-frozen-array"><span class="secno">2.11.32</span> <span class="content">Frozen array types — FrozenArray<<var>T</var>></span></a>
</ol>
<li><a href="#idl-extended-attributes"><span class="secno">2.12</span> <span class="content">Extended attributes</span></a>
</ol>
<li>
<a href="#ecmascript-binding"><span class="secno">3</span> <span class="content">ECMAScript binding</span></a>
<ol class="toc">
<li><a href="#es-environment"><span class="secno">3.1</span> <span class="content">ECMAScript environment</span></a>
<li>
<a href="#es-type-mapping"><span class="secno">3.2</span> <span class="content">ECMAScript type mapping</span></a>
<ol class="toc">
<li><a href="#es-any"><span class="secno">3.2.1</span> <span class="content">any</span></a>
<li><a href="#es-void"><span class="secno">3.2.2</span> <span class="content">void</span></a>
<li><a href="#es-boolean"><span class="secno">3.2.3</span> <span class="content">boolean</span></a>
<li><a href="#es-byte"><span class="secno">3.2.4</span> <span class="content">byte</span></a>
<li><a href="#es-octet"><span class="secno">3.2.5</span> <span class="content">octet</span></a>
<li><a href="#es-short"><span class="secno">3.2.6</span> <span class="content">short</span></a>
<li><a href="#es-unsigned-short"><span class="secno">3.2.7</span> <span class="content">unsigned short</span></a>
<li><a href="#es-long"><span class="secno">3.2.8</span> <span class="content">long</span></a>
<li><a href="#es-unsigned-long"><span class="secno">3.2.9</span> <span class="content">unsigned long</span></a>
<li><a href="#es-long-long"><span class="secno">3.2.10</span> <span class="content">long long</span></a>
<li><a href="#es-unsigned-long-long"><span class="secno">3.2.11</span> <span class="content">unsigned long long</span></a>
<li><a href="#es-float"><span class="secno">3.2.12</span> <span class="content">float</span></a>
<li><a href="#es-unrestricted-float"><span class="secno">3.2.13</span> <span class="content">unrestricted float</span></a>
<li><a href="#es-double"><span class="secno">3.2.14</span> <span class="content">double</span></a>
<li><a href="#es-unrestricted-double"><span class="secno">3.2.15</span> <span class="content">unrestricted double</span></a>
<li><a href="#es-DOMString"><span class="secno">3.2.16</span> <span class="content">DOMString</span></a>
<li><a href="#es-ByteString"><span class="secno">3.2.17</span> <span class="content">ByteString</span></a>
<li><a href="#es-USVString"><span class="secno">3.2.18</span> <span class="content">USVString</span></a>
<li><a href="#es-object"><span class="secno">3.2.19</span> <span class="content">object</span></a>
<li><a href="#es-interface"><span class="secno">3.2.20</span> <span class="content">Interface types</span></a>
<li><a href="#es-dictionary"><span class="secno">3.2.21</span> <span class="content">Dictionary types</span></a>
<li><a href="#es-enumeration"><span class="secno">3.2.22</span> <span class="content">Enumeration types</span></a>
<li><a href="#es-callback-function"><span class="secno">3.2.23</span> <span class="content">Callback function types</span></a>
<li><a href="#es-nullable-type"><span class="secno">3.2.24</span> <span class="content">Nullable types — <var>T</var>?</span></a>
<li>
<a href="#es-sequence"><span class="secno">3.2.25</span> <span class="content">Sequences — sequence<<var>T</var>></span></a>
<ol class="toc">
<li><a href="#create-sequence-from-iterable"><span class="secno">3.2.25.1</span> <span class="content">Creating a sequence from an iterable</span></a>
</ol>
<li><a href="#es-open-dictionary"><span class="secno">3.2.26</span> <span class="content">Open dictionaries — OpenDictionary<[<var>K</var>,] <var>V</var>></span></a>
<li><a href="#es-promise"><span class="secno">3.2.27</span> <span class="content">Promise types — Promise<<var>T</var>></span></a>
<li><a href="#es-union"><span class="secno">3.2.28</span> <span class="content">Union types</span></a>
<li><a href="#es-RegExp"><span class="secno">3.2.29</span> <span class="content">RegExp</span></a>
<li><a href="#es-Error"><span class="secno">3.2.30</span> <span class="content">Error</span></a>
<li><a href="#es-DOMException"><span class="secno">3.2.31</span> <span class="content">DOMException</span></a>
<li><a href="#es-buffer-source-types"><span class="secno">3.2.32</span> <span class="content">Buffer source types</span></a>
<li>
<a href="#es-frozen-array"><span class="secno">3.2.33</span> <span class="content">Frozen arrays — FrozenArray<<var>T</var>></span></a>
<ol class="toc">
<li><a href="#create-frozen-array-from-iterable"><span class="secno">3.2.33.1</span> <span class="content">Creating a frozen array from an iterable</span></a>
</ol>
</ol>
<li>
<a href="#es-extended-attributes"><span class="secno">3.3</span> <span class="content">ECMAScript-specific extended attributes</span></a>
<ol class="toc">
<li><a href="#Clamp"><span class="secno">3.3.1</span> <span class="content">[Clamp]</span></a>
<li><a href="#Constructor"><span class="secno">3.3.2</span> <span class="content">[Constructor]</span></a>
<li><a href="#EnforceRange"><span class="secno">3.3.3</span> <span class="content">[EnforceRange]</span></a>
<li><a href="#Exposed"><span class="secno">3.3.4</span> <span class="content">[Exposed]</span></a>
<li><a href="#Global"><span class="secno">3.3.5</span> <span class="content">[Global] and [PrimaryGlobal]</span></a>
<li><a href="#LegacyArrayClass"><span class="secno">3.3.6</span> <span class="content">[LegacyArrayClass]</span></a>
<li><a href="#LegacyUnenumerableNamedProperties"><span class="secno">3.3.7</span> <span class="content">[LegacyUnenumerableNamedProperties]</span></a>
<li><a href="#LenientSetter"><span class="secno">3.3.8</span> <span class="content">[LenientSetter]</span></a>
<li><a href="#LenientThis"><span class="secno">3.3.9</span> <span class="content">[LenientThis]</span></a>
<li><a href="#NamedConstructor"><span class="secno">3.3.10</span> <span class="content">[NamedConstructor]</span></a>
<li><a href="#NewObject"><span class="secno">3.3.11</span> <span class="content">[NewObject]</span></a>
<li><a href="#NoInterfaceObject"><span class="secno">3.3.12</span> <span class="content">[NoInterfaceObject]</span></a>
<li><a href="#OverrideBuiltins"><span class="secno">3.3.13</span> <span class="content">[OverrideBuiltins]</span></a>
<li><a href="#PutForwards"><span class="secno">3.3.14</span> <span class="content">[PutForwards]</span></a>
<li><a href="#Replaceable"><span class="secno">3.3.15</span> <span class="content">[Replaceable]</span></a>
<li><a href="#SameObject"><span class="secno">3.3.16</span> <span class="content">[SameObject]</span></a>
<li><a href="#SecureContext"><span class="secno">3.3.17</span> <span class="content">[SecureContext]</span></a>
<li><a href="#TreatNonObjectAsNull"><span class="secno">3.3.18</span> <span class="content">[TreatNonObjectAsNull]</span></a>
<li><a href="#TreatNullAs"><span class="secno">3.3.19</span> <span class="content">[TreatNullAs]</span></a>
<li><a href="#Unforgeable"><span class="secno">3.3.20</span> <span class="content">[Unforgeable]</span></a>
<li><a href="#Unscopable"><span class="secno">3.3.21</span> <span class="content">[Unscopable]</span></a>
</ol>
<li><a href="#es-security"><span class="secno">3.4</span> <span class="content">Security</span></a>
<li><a href="#es-overloads"><span class="secno">3.5</span> <span class="content">Overload resolution algorithm</span></a>
<li>
<a href="#es-interfaces"><span class="secno">3.6</span> <span class="content">Interfaces</span></a>
<ol class="toc">
<li>
<a href="#interface-object"><span class="secno">3.6.1</span> <span class="content">Interface object</span></a>
<ol class="toc">
<li><a href="#es-interface-call"><span class="secno">3.6.1.1</span> <span class="content">Interface object [[Call]] method</span></a>
<li><a href="#es-interface-hasinstance"><span class="secno">3.6.1.2</span> <span class="content">Interface object [[HasInstance]] method</span></a>
</ol>
<li><a href="#named-constructors"><span class="secno">3.6.2</span> <span class="content">Named constructors</span></a>
<li><a href="#interface-prototype-object"><span class="secno">3.6.3</span> <span class="content">Interface prototype object</span></a>
<li>
<a href="#named-properties-object"><span class="secno">3.6.4</span> <span class="content">Named properties object</span></a>
<ol class="toc">
<li><a href="#named-properties-object-getownproperty"><span class="secno">3.6.4.1</span> <span class="content">Named properties object [[GetOwnProperty]] method</span></a>
<li><a href="#named-properties-object-defineownproperty"><span class="secno">3.6.4.2</span> <span class="content">Named properties object [[DefineOwnProperty]] method</span></a>
<li><a href="#named-properties-object-delete"><span class="secno">3.6.4.3</span> <span class="content">Named properties object [[Delete]] method</span></a>
<li><a href="#named-properties-object-setprototypeof"><span class="secno">3.6.4.4</span> <span class="content">Named properties object [[SetPrototypeOf]] method</span></a>
</ol>
<li><a href="#es-constants"><span class="secno">3.6.5</span> <span class="content">Constants</span></a>
<li><a href="#es-attributes"><span class="secno">3.6.6</span> <span class="content">Attributes</span></a>
<li>
<a href="#es-operations"><span class="secno">3.6.7</span> <span class="content">Operations</span></a>
<ol class="toc">
<li><a href="#es-stringifier"><span class="secno">3.6.7.1</span> <span class="content">Stringifiers</span></a>
<li><a href="#es-serializer"><span class="secno">3.6.7.2</span> <span class="content">Serializers</span></a>
</ol>
<li>
<a href="#es-iterators"><span class="secno">3.6.8</span> <span class="content">Common iterator behavior</span></a>
<ol class="toc">
<li><a href="#es-iterator"><span class="secno">3.6.8.1</span> <span class="content">@@iterator</span></a>
<li><a href="#es-forEach"><span class="secno">3.6.8.2</span> <span class="content">forEach</span></a>
</ol>
<li>
<a href="#es-iterable"><span class="secno">3.6.9</span> <span class="content">Iterable declarations</span></a>
<ol class="toc">
<li><a href="#es-iterable-entries"><span class="secno">3.6.9.1</span> <span class="content">entries</span></a>
<li><a href="#es-iterable-keys"><span class="secno">3.6.9.2</span> <span class="content">keys</span></a>
<li><a href="#es-iterable-values"><span class="secno">3.6.9.3</span> <span class="content">values</span></a>
<li><a href="#es-default-iterator-object"><span class="secno">3.6.9.4</span> <span class="content">Default iterator objects</span></a>
<li><a href="#es-iterator-prototype-object"><span class="secno">3.6.9.5</span> <span class="content">Iterator prototype object</span></a>
</ol>
<li>
<a href="#es-maplike"><span class="secno">3.6.10</span> <span class="content">Maplike declarations</span></a>
<ol class="toc">
<li><a href="#es-map-size"><span class="secno">3.6.10.1</span> <span class="content">size</span></a>
<li><a href="#es-map-entries"><span class="secno">3.6.10.2</span> <span class="content">entries</span></a>
<li><a href="#es-map-keys-values"><span class="secno">3.6.10.3</span> <span class="content">keys and values</span></a>
<li><a href="#es-map-get-has"><span class="secno">3.6.10.4</span> <span class="content">get and has</span></a>
<li><a href="#es-map-clear"><span class="secno">3.6.10.5</span> <span class="content">clear</span></a>
<li><a href="#es-map-delete"><span class="secno">3.6.10.6</span> <span class="content">delete</span></a>
<li><a href="#es-map-set"><span class="secno">3.6.10.7</span> <span class="content">set</span></a>
</ol>
<li>
<a href="#es-setlike"><span class="secno">3.6.11</span> <span class="content">Setlike declarations</span></a>
<ol class="toc">
<li><a href="#es-set-size"><span class="secno">3.6.11.1</span> <span class="content">size</span></a>
<li><a href="#es-set-values"><span class="secno">3.6.11.2</span> <span class="content">values</span></a>
<li><a href="#es-set-entries-keys"><span class="secno">3.6.11.3</span> <span class="content">entries and keys</span></a>
<li><a href="#es-set-has"><span class="secno">3.6.11.4</span> <span class="content">has</span></a>
<li><a href="#es-add-delete"><span class="secno">3.6.11.5</span> <span class="content">add and delete</span></a>
<li><a href="#es-set-clear"><span class="secno">3.6.11.6</span> <span class="content">clear</span></a>
</ol>
</ol>
<li><a href="#es-implements-statements"><span class="secno">3.7</span> <span class="content">Implements statements</span></a>
<li>
<a href="#es-platform-objects"><span class="secno">3.8</span> <span class="content">Platform objects implementing interfaces</span></a>
<ol class="toc">
<li><a href="#indexed-and-named-properties"><span class="secno">3.8.1</span> <span class="content">Indexed and named properties</span></a>
<li><a href="#getownproperty-guts"><span class="secno">3.8.2</span> <span class="content">The PlatformObjectGetOwnProperty abstract operation</span></a>
<li><a href="#getownproperty"><span class="secno">3.8.3</span> <span class="content">Platform object [[GetOwnProperty]] method</span></a>
<li><a href="#invoking-indexed-setter"><span class="secno">3.8.4</span> <span class="content">Invoking a platform object indexed property setter</span></a>
<li><a href="#invoking-named-setter"><span class="secno">3.8.5</span> <span class="content">Invoking a platform object named property setter</span></a>
<li><a href="#platformobjectset"><span class="secno">3.8.6</span> <span class="content">Platform object [[Set]] method</span></a>
<li><a href="#defineownproperty"><span class="secno">3.8.7</span> <span class="content">Platform object [[DefineOwnProperty]] method</span></a>
<li><a href="#delete"><span class="secno">3.8.8</span> <span class="content">Platform object [[Delete]] method</span></a>
<li><a href="#call"><span class="secno">3.8.9</span> <span class="content">Platform object [[Call]] method</span></a>
<li><a href="#property-enumeration"><span class="secno">3.8.10</span> <span class="content">Property enumeration</span></a>
</ol>
<li><a href="#es-user-objects"><span class="secno">3.9</span> <span class="content">User objects implementing callback interfaces</span></a>
<li><a href="#es-invoking-callback-functions"><span class="secno">3.10</span> <span class="content">Invoking callback functions</span></a>
<li>
<a href="#es-namespaces"><span class="secno">3.11</span> <span class="content">Namespaces</span></a>
<ol class="toc">
<li><a href="#namespace-object"><span class="secno">3.11.1</span> <span class="content">Namespace object</span></a>
</ol>
<li>
<a href="#es-exceptions"><span class="secno">3.12</span> <span class="content">Exceptions</span></a>
<ol class="toc">
<li>
<a href="#es-DOMException-constructor-object"><span class="secno">3.12.1</span> <span class="content">DOMException constructor object</span></a>
<ol class="toc">
<li><a href="#es-DOMException-call"><span class="secno">3.12.1.1</span> <span class="content">DOMException(message, name)</span></a>
</ol>
<li><a href="#es-DOMException-prototype-object"><span class="secno">3.12.2</span> <span class="content">DOMException prototype object</span></a>
</ol>
<li><a href="#es-exception-objects"><span class="secno">3.13</span> <span class="content">Exception objects</span></a>
<li><a href="#es-creating-throwing-exceptions"><span class="secno">3.14</span> <span class="content">Creating and throwing exceptions</span></a>
<li><a href="#es-handling-exceptions"><span class="secno">3.15</span> <span class="content">Handling exceptions</span></a>
</ol>
<li>
<a href="#common"><span class="secno">4</span> <span class="content">Common definitions</span></a>
<ol class="toc">
<li><a href="#ArrayBufferView"><span class="secno">4.1</span> <span class="content">ArrayBufferView</span></a>
<li><a href="#BufferSource"><span class="secno">4.2</span> <span class="content">BufferSource</span></a>
<li><a href="#DOMTimeStamp"><span class="secno">4.3</span> <span class="content">DOMTimeStamp</span></a>
<li><a href="#Function"><span class="secno">4.4</span> <span class="content">Function</span></a>
<li><a href="#VoidFunction"><span class="secno">4.5</span> <span class="content">VoidFunction</span></a>
</ol>
<li><a href="#extensibility"><span class="secno">5</span> <span class="content">Extensibility</span></a>
<li><a href="#referencing"><span class="secno">6</span> <span class="content">Referencing this specification</span></a>
<li><a href="#acknowledgements"><span class="secno">7</span> <span class="content">Acknowledgements</span></a>
<li><a href="#idl-grammar"><span class="secno"></span> <span class="content">IDL grammar</span></a>
<li><a href="#conventions"><span class="secno"></span> <span class="content">Document conventions</span></a>
<li><a href="#conformance"><span class="secno"></span> <span class="content">Conformance</span></a>
<li>
<a href="#index"><span class="secno"></span> <span class="content">Index</span></a>
<ol class="toc">
<li><a href="#index-defined-here"><span class="secno"></span> <span class="content">Terms defined by this specification</span></a>
<li><a href="#index-defined-elsewhere"><span class="secno"></span> <span class="content">Terms defined by reference</span></a>
</ol>
<li>
<a href="#references"><span class="secno"></span> <span class="content">References</span></a>
<ol class="toc">
<li><a href="#normative"><span class="secno"></span> <span class="content">Normative References</span></a>
<li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
</ol>
<li><a href="#idl-index"><span class="secno"></span> <span class="content">IDL Index</span></a>
</ol>
</nav>
<main>
<h2 class="heading settled" data-level="1" id="introduction"><span class="secno">1. </span><span class="content">Introduction</span><a class="self-link" href="#introduction"></a></h2>
<p><i>This section is informative.</i></p>
<p>Technical reports published by the W3C that include programming
language interfaces have typically been described using the
Object Management Group’s Interface Definition Language (IDL) <a data-link-type="biblio" href="#biblio-omgidl">[OMGIDL]</a>. The IDL provides a means to
describe these interfaces in a language independent manner. Usually,
additional language binding appendices are included in such
documents which detail how the interfaces described with the IDL
correspond to constructs in the given language.</p>
<p>However, the bindings in these specifications for the language most
commonly used on the web, ECMAScript, are consistently specified with
low enough precision as to result in interoperability issues. In
addition, each specification must describe the same basic information,
such as DOM interfaces described in IDL corresponding to properties
on the ECMAScript global object, or the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-1">unsigned long</a></code> IDL type mapping to the <emu-val>Number</emu-val> type in ECMAScript.</p>
<p>This specification defines an IDL language similar to OMG IDL
for use by specifications that define interfaces for Web APIs. A number of extensions are
given to the IDL to support common functionality that previously must
have been written in prose. In addition, precise language bindings
for ECMAScript Edition 6 are given.</p>
<h2 class="heading settled" data-level="2" id="idl"><span class="secno">2. </span><span class="content">Interface definition language</span><a class="self-link" href="#idl"></a></h2>
<p>This section describes a language, <em>Web IDL</em>, which can be used to define
interfaces for APIs in the Web platform. A specification that defines Web APIs
can include one or more <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="IDL fragment" id="dfn-idl-fragment">IDL fragments</dfn> that
describe the interfaces (the state and behavior that objects can exhibit)
for the APIs defined by that specification.
An <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-1">IDL fragment</a> is
a sequence of definitions that matches the <emu-nt><a href="#prod-Definitions">Definitions</a></emu-nt> grammar symbol.
The set of <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-2">IDL fragments</a> that
an implementation supports is not ordered.
See <a href="#idl-grammar">IDL grammar</a> for the complete grammar and an explanation of the notation used.</p>
<p>The different kinds of <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="dfn-definition">definitions</dfn> that can appear in an <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-3">IDL fragment</a> are: <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-1">interfaces</a>, <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-1">partial interface definitions</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-1">namespaces</a>, <a data-link-type="dfn" href="#dfn-partial-namespace" id="ref-for-dfn-partial-namespace-1">partial namespace definitions</a>, <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-1">dictionaries</a>, <a data-link-type="dfn" href="#dfn-partial-dictionary" id="ref-for-dfn-partial-dictionary-1">partial dictionary definitions</a>, <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-1">typedefs</a> and <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-1">implements statements</a>.
These are all defined in the following sections.</p>
<p>Each <a data-link-type="dfn" href="#dfn-definition" id="ref-for-dfn-definition-1">definition</a> (matching <emu-nt><a href="#prod-Definition">Definition</a></emu-nt>)
can be preceded by a list of <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-1">extended attributes</a> (matching <emu-nt><a href="#prod-ExtendedAttributeList">ExtendedAttributeList</a></emu-nt>),
which can control how the definition will be handled in language bindings.
The extended attributes defined by this specification that are language binding
agnostic are discussed in <a href="#idl-extended-attributes">§2.12 Extended attributes</a>,
while those specific to the ECMAScript language binding are discussed
in <a href="#es-extended-attributes">§3.3 ECMAScript-specific extended attributes</a>.</p>
<pre class="syntax highlight">[<mark><span class="nv">extended_attributes</span></mark>]
<span class="kt">interface</span> <span class="nv">identifier</span> {
/* interface_members... */
};
</pre>
<pre class="grammar" id="prod-Definitions">Definitions :
ExtendedAttributeList Definition Definitions
ε
</pre>
<pre class="grammar" id="prod-Definition">Definition :
CallbackOrInterface
Namespace
Partial
Dictionary
Enum
Typedef
ImplementsStatement
</pre>
<pre class="grammar" id="prod-CallbackOrInterface">CallbackOrInterface :
"callback" CallbackRestOrInterface
Interface
</pre>
<div class="example" id="example-1e2a005b">
<a class="self-link" href="#example-1e2a005b"></a>
<p>The following is an example of an <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-4">IDL fragment</a>.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Paint</span> { };
<span class="kt">interface</span> <span class="nv">SolidColor</span> : <span class="n">Paint</span> {
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">red</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">green</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">blue</span>;
};
<span class="kt">interface</span> <span class="nv">Pattern</span> : <span class="n">Paint</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">imageURL</span>;
};
[<span class="nv">Constructor</span>]
<span class="kt">interface</span> <span class="nv">GraphicalWindow</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">width</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">height</span>;
<span class="kt">attribute</span> <span class="n">Paint</span> <span class="nv">currentPaint</span>;
<span class="kt">void</span> <span class="nv">drawRectangle</span>(<span class="kt">double</span> <span class="nv">x</span>, <span class="kt">double</span> <span class="nv">y</span>, <span class="kt">double</span> <span class="nv">width</span>, <span class="kt">double</span> <span class="nv">height</span>);
<span class="kt">void</span> <span class="nv">drawText</span>(<span class="kt">double</span> <span class="nv">x</span>, <span class="kt">double</span> <span class="nv">y</span>, <span class="kt">DOMString</span> <span class="nv">text</span>);
};
</pre>
<p>Here, four <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-2">interfaces</a> are being defined.
The <code class="idl">GraphicalWindow</code> interface has two <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-1">read only</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-1">attributes</a>,
one writable attribute, and two <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-1">operations</a> defined on it. Objects that implement the <code class="idl">GraphicalWindow</code> interface
will expose these attributes and operations in a manner appropriate to the
particular language being used.</p>
<p>In ECMAScript, the attributes on the IDL interfaces will be exposed as accessor
properties and the operations as <emu-val>Function</emu-val>-valued
data properties on a prototype object for all <code class="idl">GraphicalWindow</code> objects; each ECMAScript object that implements <code class="idl">GraphicalWindow</code> will have that prototype object in its prototype chain.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-1">Constructor</a></code>] that appears on <code class="idl">GraphicalWindow</code> is an <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-2">extended attribute</a>.
This extended attribute causes a constructor to exist in ECMAScript implementations,
so that calling <code>new GraphicalWindow()</code> would return a new object
that implemented the interface.</p>
</div>
<h3 class="heading settled" data-level="2.1" id="idl-names"><span class="secno">2.1. </span><span class="content">Names</span><a class="self-link" href="#idl-names"></a></h3>
<p>Every <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-3">interface</a>, <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-2">partial interface definition</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-2">namespace</a>, <a data-link-type="dfn" href="#dfn-partial-namespace" id="ref-for-dfn-partial-namespace-2">partial namespace definition</a>, <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-2">dictionary</a>, <a data-link-type="dfn" href="#dfn-partial-dictionary" id="ref-for-dfn-partial-dictionary-2">partial dictionary definition</a>, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-1">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-1">callback function</a> and <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-2">typedef</a> (together called <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="named definition" id="dfn-named-definition">named definitions</dfn>)
and every <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-1">constant</a>, <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-2">attribute</a>,
and <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-1">dictionary member</a> has an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-identifier">identifier</dfn>, as do some <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-2">operations</a>.
The identifier is determined by an <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token somewhere
in the declaration:</p>
<ul>
<li data-md="">
<p>For <a data-link-type="dfn" href="#dfn-named-definition" id="ref-for-dfn-named-definition-1">named definitions</a>,
the <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token that appears
directly after the <code>interface</code>, <code>namespace</code>, <code>dictionary</code>, <code>enum</code> or <code>callback</code> keyword
determines the identifier of that definition.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <mark><span class="nv">interface_identifier</span></mark> { /* interface_members... */ };
<span class="kt">partial</span> <span class="kt">interface</span> <mark><span class="nv">interface_identifier</span></mark> { /* interface_members... */ };
<span class="kt">namespace</span> <mark><span class="nv">namespace_identifier</span></mark> { /* namespace_members... */ };
<span class="kt">partial</span> <span class="kt">namespace</span> <mark><span class="nv">namespace_identifier</span></mark> { /* namespace_members... */ };
<span class="kt">dictionary</span> <mark><span class="nv">dictionary_identifier</span></mark> { /* dictionary_members... */ };
<span class="kt">partial</span> <span class="kt">dictionary</span> <mark><span class="nv">dictionary_identifier</span></mark> { /* dictionary_members... */ };
<span class="kt">enum</span> <mark><span class="nv">enumeration_identifier</span></mark> { <span class="s">"enum"</span>, <span class="s">"values"</span> /* , ... */ };
<span class="kt">callback</span> <mark><span class="nv">callback_identifier</span></mark> = <span class="n">return_type</span> (/* arguments... */);
</pre>
<li data-md="">
<p>For <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-3">attributes</a>, <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-3">typedefs</a> and <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-2">dictionary members</a>,
the final <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token before the
semicolon at the end of the declaration determines the identifier.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">identifier</span> {
<span class="kt">attribute</span> <span class="n">type</span> <mark><span class="nv">attribute_identifier</span></mark>;
};
<span class="kt">typedef</span> <span class="n">type</span> <mark><span class="nv">typedef_identifier</span></mark>;
<span class="kt">dictionary</span> <span class="nv">identifier</span> {
<span class="n">type</span> <mark><span class="nv">dictionary_member_identifier</span></mark>;
};
</pre>
<li data-md="">
<p>For <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-2">constants</a>,
the <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token before the
equals sign determines the identifier.</p>
<pre class="syntax highlight"><span class="kt">const</span> <span class="n">type</span> <mark><span class="nv">constant_identifier</span></mark> = 42;</pre>
<li data-md="">
<p>For <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-3">operations</a>, the <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token that appears
after the return type but before the opening parenthesis (that is,
one that is matched as part of the <emu-nt><a href="#prod-OptionalIdentifier">OptionalIdentifier</a></emu-nt> grammar symbol in an <emu-nt><a href="#prod-OperationRest">OperationRest</a></emu-nt>) determines the identifier of the operation. If
there is no such <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token,
then the operation does not have an identifier.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <mark><span class="nv">operation_identifier</span></mark>(/* arguments... */);
};
</pre>
</ul>
<p class="note" role="note">Note: Operations can have no identifier when they are being used to declare a <a data-link-type="dfn" href="#dfn-special-operation" id="ref-for-dfn-special-operation-1">special kind of operation</a>, such as a getter or setter.</p>
<p>For all of these constructs, the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-1">identifier</a> is the value of the <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token with any leading <span class="char">U+005F LOW LINE ("_")</span> character (underscore) removed.</p>
<p class="note" role="note">Note: A leading <span class="char">"_"</span> is used to escape an identifier from looking
like a reserved word so that, for example, an interface named “interface” can be
defined. The leading <span class="char">"_"</span> is dropped to unescape the
identifier.</p>
<p>Operation arguments can take a slightly wider set of identifiers. In an operation
declaration, the identifier of an argument is specified immediately after its
type and is given by either an <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token or by one of the keywords that match the <emu-nt><a href="#prod-ArgumentNameKeyword">ArgumentNameKeyword</a></emu-nt> symbol. If one of these keywords is used, it need not be escaped with a leading
underscore.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">operation_identifier</span>(<span class="n">argument_type</span> <mark><span class="nv">argument_identifier</span></mark> /* , ... */);
};
</pre>
<pre class="grammar" id="prod-ArgumentNameKeyword">ArgumentNameKeyword :
"attribute"
"callback"
"const"
"deleter"
"dictionary"
"enum"
"getter"
"implements"
"inherit"
"interface"
"iterable"
"legacycaller"
"maplike"
"namespace"
"partial"
"required"
"serializer"
"setlike"
"setter"
"static"
"stringifier"
"typedef"
"unrestricted"
</pre>
<p>If an <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token is used, then the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-2">identifier</a> of the operation argument
is the value of that token with any leading <span class="char">U+005F LOW LINE ("_")</span> character (underscore) removed.
If instead one of the <emu-nt><a href="#prod-ArgumentNameKeyword">ArgumentNameKeyword</a></emu-nt> keyword token is used, then the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-3">identifier</a> of the operation argument
is simply that token.</p>
<p>The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-4">identifier</a> of any of the abovementioned
IDL constructs must not be “constructor”,
“toString”, “toJSON”,
or begin with a <span class="char">U+005F LOW LINE ("_")</span> character. These
are known as <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-reserved-identifier">reserved identifiers</dfn>.</p>
<p class="note" role="note">Note: Further restrictions on identifier names for particular constructs may be made
in later sections.</p>
<p>Within the set of <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-5">IDL fragments</a> that a given implementation supports,
the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-5">identifier</a> of every <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-4">interface</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-3">namespace</a>, <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-3">dictionary</a>, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-2">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-2">callback function</a> and <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-4">typedef</a> must not
be the same as the identifier of any other <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-5">interface</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-4">namespace</a>, <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-4">dictionary</a>, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-3">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-3">callback function</a> or <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-5">typedef</a>.</p>
<p>Within an <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-6">IDL fragment</a>, a reference
to a <a data-link-type="dfn" href="#dfn-definition" id="ref-for-dfn-definition-2">definition</a> need not appear after
the declaration of the referenced definition. References can also be made
across <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-7">IDL fragments</a>.</p>
<div class="example" id="example-c005dcea">
<a class="self-link" href="#example-c005dcea"></a>
<p>Therefore, the following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-8">IDL fragment</a> is valid:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">B</span> : <span class="n">A</span> {
<span class="kt">void</span> <span class="nv">f</span>(<span class="n">SequenceOfLongs</span> <span class="nv">x</span>);
};
<span class="kt">interface</span> <span class="nv">A</span> {
};
<span class="kt">typedef</span> <span class="kt">sequence</span><<span class="kt">long</span>> <span class="nv">SequenceOfLongs</span>;
</pre>
</div>
<div class="example" id="example-82b99746">
<a class="self-link" href="#example-82b99746"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-9">IDL fragment</a> demonstrates how <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-6">identifiers</a> are given to definitions and <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-1">interface members</a>.</p>
<pre class="highlight">// Typedef identifier: "number"
<span class="kt">typedef</span> <span class="kt">double</span> <span class="nv">number</span>;
// Interface identifier: "System"
<span class="kt">interface</span> <span class="nv">System</span> {
// Operation identifier: "createObject"
// Operation argument identifier: "interface"
<span class="kt">object</span> <span class="nv">createObject</span>(<span class="kt">DOMString</span> <span class="nv">_interface</span>);
// Operation argument identifier: "interface"
<span class="kt">sequence</span><<span class="kt">object</span>> <span class="nv">getObjects</span>(<span class="kt">DOMString</span> <span class="nv">interface</span>);
// Operation has no identifier; it declares a getter.
<span class="kt">getter</span> <span class="kt">DOMString</span> (<span class="kt">DOMString</span> <span class="nv">keyName</span>);
};
// Interface identifier: "TextField"
<span class="kt">interface</span> <span class="nv">TextField</span> {
// Attribute identifier: "const"
<span class="kt">attribute</span> <span class="kt">boolean</span> <span class="nv">_const</span>;
// Attribute identifier: "value"
<span class="kt">attribute</span> <span class="kt">DOMString</span>? <span class="nv">_value</span>;
};
</pre>
<p>Note that while the second <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-4">attribute</a> on the <code class="idl">TextField</code> <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-6">interface</a> need not have been escaped with an underscore (because “value” is
not a keyword in the IDL grammar), it is still unescaped
to obtain the attribute’s <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-7">identifier</a>.</p>
</div>
<h3 class="heading settled" data-level="2.2" id="idl-interfaces"><span class="secno">2.2. </span><span class="content">Interfaces</span><a class="self-link" href="#idl-interfaces"></a></h3>
<p><a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-10">IDL fragments</a> are used to
describe object oriented systems. In such systems, objects are entities
that have identity and which are encapsulations of state and behavior.
An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-interface">interface</dfn> is a definition (matching <emu-nt><a href="#prod-Interface">Interface</a></emu-nt> or <emu-t>callback</emu-t> <emu-nt><a href="#prod-Interface">Interface</a></emu-nt>) that declares some
state and behavior that an object implementing that interface will expose.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">identifier</span> {
/* interface_members... */
};
</pre>
<p>An interface is a specification of a set of <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="interface member" id="dfn-interface-member">interface members</dfn> (matching <emu-nt><a href="#prod-InterfaceMembers">InterfaceMembers</a></emu-nt>),
which are the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-3">constants</a>, <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-5">attributes</a>, <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-4">operations</a> and
other declarations that appear between the braces in the interface declaration.
Attributes describe the state that an object
implementing the interface will expose, and operations describe the
behaviors that can be invoked on the object. Constants declare
named constant values that are exposed as a convenience to users
of objects in the system.</p>
<p>Interfaces in Web IDL describe how objects that implement the
interface behave. In bindings for object oriented languages, it is
expected that an object that implements a particular IDL interface
provides ways to inspect and modify the object’s state and to
invoke the behavior described by the interface.</p>
<p>An interface can be defined to <dfn class="dfn-paneled" data-dfn-for="interface" data-dfn-type="dfn" data-export="" id="dfn-inherit">inherit</dfn> from another interface.
If the identifier of the interface is followed by a <span class="char">U+003A COLON (":")</span> character
and an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-8">identifier</a>,
then that identifier identifies the inherited interface.
An object that implements an interface that inherits from another
also implements that inherited interface. The object therefore will also
have members that correspond to the interface members from the inherited interface.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">identifier</span> : <mark><span class="n">identifier_of_inherited_interface</span></mark> {
/* interface_members... */
};
</pre>
<p>The order that members appear in has significance for property enumeration in the <a href="#es-interfaces">ECMAScript binding</a>.</p>
<p>Interfaces may specify an interface member that has the same name as
one from an inherited interface. Objects that implement the derived
interface will expose the member on the derived interface. It is
language binding specific whether the overridden member can be
accessed on the object.</p>
<div class="example" id="example-e0fcd466">
<a class="self-link" href="#example-e0fcd466"></a>
<p>Consider the following two interfaces.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">f</span>();
<span class="kt">void</span> <span class="nv">g</span>();
};
<span class="kt">interface</span> <span class="nv">B</span> : <span class="n">A</span> {
<span class="kt">void</span> <span class="nv">f</span>();
<span class="kt">void</span> <span class="nv">g</span>(<span class="kt">DOMString</span> <span class="nv">x</span>);
};
</pre>
<p>In the ECMAScript language binding, an instance of <code class="idl">B</code> will have a prototype chain that looks like the following:</p>
<pre>[Object.prototype: the Object prototype object]
↑
[A.prototype: interface prototype object for A]
↑
[B.prototype: interface prototype object for B]
↑
[instanceOfB]
</pre>
<p>Calling <code>instanceOfB.f()</code> in ECMAScript will invoke the f defined
on <code class="idl">B</code>. However, the f from <code class="idl">A</code> can still be invoked on an object that implements <code class="idl">B</code> by
calling <code>A.prototype.f.call(instanceOfB)</code>.</p>
</div>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-inherited-interfaces">inherited interfaces</dfn> of
a given interface <var>A</var> is the set of all interfaces that <var>A</var> inherits from, directly or indirectly. If <var>A</var> does not <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-1">inherit</a> from another interface, then the set is empty. Otherwise, the set
includes the interface <var>B</var> that <var>A</var> <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-2">inherits</a> from and all of <var>B</var>’s <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-1">inherited interfaces</a>.</p>
<p>An interface must not be declared such that
its inheritance hierarchy has a cycle. That is, an interface <var>A</var> cannot inherit from itself, nor can it inherit from another
interface <var>B</var> that inherits from <var>A</var>, and so on.</p>
<p>Note that general multiple inheritance of interfaces is not supported, and
objects also cannot implement arbitrary sets of interfaces.
Objects can be defined to implement a single given interface <var>A</var>,
which means that it also implements all of <var>A</var>’s <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-2">inherited interfaces</a>. In addition,
an <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-2">implements statement</a> can be
used to define that objects implementing an interface will always
also implement another interface.</p>
<p>Each interface member can be preceded by a list of <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-3">extended attributes</a> (matching <emu-nt><a href="#prod-ExtendedAttributeList">ExtendedAttributeList</a></emu-nt>),
which can control how the interface member will be handled in language bindings.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">identifier</span> {
[<mark><span class="nv">extended_attributes</span></mark>]
<span class="kt">const</span> <span class="n">type</span> <span class="nv">constant_identifier</span> = 42;
[<mark><span class="nv">extended_attributes</span></mark>]
<span class="kt">attribute</span> <span class="n">type</span> <span class="nv">identifier</span>;
[<mark><span class="nv">extended_attributes</span></mark>]
<span class="n">return_type</span> <span class="nv">identifier</span>(/* arguments... */);
};
</pre>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-callback-interface">callback interface</dfn> is
an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-7">interface</a> that uses the <code>callback</code> keyword at the start of
its definition. Callback interfaces are ones that can be
implemented by <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-1">user objects</a> and not by <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-1">platform objects</a>,
as described in <a href="#idl-objects">§2.10 Objects implementing interfaces</a>.</p>
<pre class="syntax highlight"><span class="kt">callback</span> <span class="kt">interface</span> <span class="nv">identifier</span> {
/* interface_members... */
};
</pre>
<p class="note" role="note">Note: See also the similarly named <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-4">callback function</a> definition.</p>
<p><a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-1">Callback interfaces</a> must not <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-3">inherit</a> from any non-callback interfaces, and non-callback interfaces must not
inherit from any callback interfaces.
Callback interfaces must not have any <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-1">consequential interfaces</a>.</p>
<p><a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-1">Static attributes</a> and <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-1">static operations</a> must not
be defined on a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-2">callback interface</a>.</p>
<div class="advisement">
<p>Specification authors should not define <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-3">callback interfaces</a> that have only a single <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-5">operation</a>,
unless required to describe the requirements of existing APIs.
Instead, a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-5">callback function</a> should be used.</p>
<p>The definition of <code class="idl">EventListener</code> as a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-4">callback interface</a> is an example of an existing API that needs to allow <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-2">user objects</a> with a
given property (in this case “handleEvent”) to be considered to implement the interface.
For new APIs, and those for which there are no compatibility concerns,
using a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-6">callback function</a> will allow
only a <emu-val>Function</emu-val> object (in the ECMAScript
language binding).</p>
</div>
<p class="issue" id="issue-a4feb7b2"><a class="self-link" href="#issue-a4feb7b2"></a> Perhaps this warning shouldn’t apply if you are planning to extend the callback
interface in the future. That’s probably a good reason to start off with a single
operation callback interface. </p>
<p class="issue" id="issue-4d2fc4e6"><a class="self-link" href="#issue-4d2fc4e6"></a> I think we need to support operations not being implemented on a given
user object implementing a callback interface. If specs extending an existing
callback interface, we probably want to be able to avoid calling the
operations that aren’t implemented (and having some default behavior instead).
So we should perhaps define a term that means whether the operation is
implemented, which in the ECMAScript binding would correspond to checking
for the property’s existence. </p>
<div class="note" role="note">
<p>Specification authors wanting to define APIs that take ECMAScript objects
as “property bag” like function arguments are suggested to use <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-5">dictionaries</a> rather than <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-5">callback interfaces</a>.</p>
<p>For example, instead of this:</p>
<pre class="highlight"><span class="kt">callback</span> <span class="kt">interface</span> <span class="nv">Options</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span>? <span class="nv">option1</span>;
<span class="kt">attribute</span> <span class="kt">DOMString</span>? <span class="nv">option2</span>;
<span class="kt">attribute</span> <span class="kt">long</span>? <span class="nv">option3</span>;
};
<span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">doTask</span>(<span class="kt">DOMString</span> <span class="nv">type</span>, <span class="n">Options</span> <span class="nv">options</span>);
};
</pre>
<p>to be used like this:</p>
<pre class="highlight"><span class="kd">var</span> a <span class="o">=</span> getA<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of A.
</span>
a<span class="p">.</span>doTask<span class="p">(</span><span class="s2">"something"</span><span class="p">,</span> <span class="p">{</span> option1<span class="o">:</span> <span class="s2">"banana"</span><span class="p">,</span> option3<span class="o">:</span> <span class="mi">100</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span>
</pre>
<p>instead write the following:</p>
<pre class="highlight"><span class="kt">dictionary</span> <span class="nv">Options</span> {
<span class="kt">DOMString</span>? <span class="nv">option1</span>;
<span class="kt">DOMString</span>? <span class="nv">option2</span>;
<span class="kt">long</span>? <span class="nv">option3</span>;
};
<span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">doTask</span>(<span class="kt">DOMString</span> <span class="nv">type</span>, <span class="kt">optional</span> <span class="n">Options</span> <span class="nv">options</span>);
};
</pre>
</div>
<p>The IDL for interfaces can be split into multiple parts by using <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-partial-interface">partial interface</dfn> definitions
(matching <emu-t>partial</emu-t> <emu-nt><a href="#prod-PartialInterface">PartialInterface</a></emu-nt>).
The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-9">identifier</a> of a partial
interface definition must be the same
as the identifier of an interface definition. All of
the members that appear on each of the partial interfaces are considered to be
members of the interface itself.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <mark><span class="nv">SomeInterface</span></mark> {
/* interface_members... */
};
<span class="kt">partial</span> <span class="kt">interface</span> <mark><span class="nv">SomeInterface</span></mark> {
/* interface_members... */
};
</pre>
<p class="note" role="note">Note: Partial interface definitions are intended for use as a specification
editorial aide, allowing the definition of an interface to be separated
over more than one section of the document, and sometimes multiple documents.</p>
<p>The order of appearance of an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-8">interface</a> definition and any of its <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-3">partial interface</a> definitions does not matter.</p>
<p class="note" role="note">Note: A partial interface definition cannot specify that the interface <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-4">inherits</a> from another interface.
Inheritance must be specified on the original <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-9">interface</a> definition.</p>
<p><a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-4">Extended attributes</a> can be specified on <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-4">partial interface</a> definitions, with some
limitations. The following extended attributes must not
be specified on partial interface definitions:
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-2">Constructor</a></code>],
[<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-1">LegacyArrayClass</a></code>],
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-1">NamedConstructor</a></code>],
[<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-1">NoInterfaceObject</a></code>].</p>
<p class="note" role="note">Note: The above list of <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-5">extended attributes</a> is all of those defined in this document that are applicable to <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-10">interfaces</a> except for
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-1">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-1">Global</a></code>],
[<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-1">OverrideBuiltins</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-2">PrimaryGlobal</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-1">SecureContext</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-1">Unforgeable</a></code>].</p>
<p>Any <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-6">extended attribute</a> specified
on a <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-5">partial interface</a> definition
is considered to appear on the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-11">interface</a> itself.</p>
<p>The relevant language binding determines how interfaces correspond to constructs
in the language.</p>
<p>The following extended attributes are applicable to interfaces:
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-3">Constructor</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-2">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-3">Global</a></code>],
[<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-2">LegacyArrayClass</a></code>],
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-2">NamedConstructor</a></code>],
[<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-2">NoInterfaceObject</a></code>],
[<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-2">OverrideBuiltins</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-4">PrimaryGlobal</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-2">SecureContext</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-2">Unforgeable</a></code>].</p>
<div data-fill-with="grammar-CallbackOrInterface"></div>
<pre class="grammar" id="prod-CallbackRestOrInterface">CallbackRestOrInterface :
CallbackRest
Interface
</pre>
<pre class="grammar" id="prod-Interface">Interface :
"interface" identifier Inheritance "{" InterfaceMembers "}" ";"
</pre>
<pre class="grammar" id="prod-Partial">Partial :
"partial" PartialDefinition
</pre>
<pre class="grammar" id="prod-PartialDefinition">PartialDefinition :
PartialInterface
PartialDictionary
Namespace
</pre>
<pre class="grammar" id="prod-PartialInterface">PartialInterface :
"interface" identifier "{" InterfaceMembers "}" ";"
</pre>
<pre class="grammar" id="prod-InterfaceMembers">InterfaceMembers :
ExtendedAttributeList InterfaceMember InterfaceMembers
ε
</pre>
<pre class="grammar" id="prod-InterfaceMember">InterfaceMember :
Const
Operation
Serializer
Stringifier
StaticMember
Iterable
ReadOnlyMember
ReadWriteAttribute
ReadWriteMaplike
ReadWriteSetlike
</pre>
<pre class="grammar" id="prod-Inheritance">Inheritance :
":" identifier
ε
</pre>
<div class="example" id="example-27f009d0">
<a class="self-link" href="#example-27f009d0"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-11">IDL fragment</a> demonstrates the definition of two mutually referential <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-12">interfaces</a>.
Both <code class="idl">Human</code> and <code class="idl">Dog</code> inherit from <code class="idl">Animal</code>. Objects that implement
either of those two interfaces will thus have a <code>name</code> attribute.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Animal</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
};
<span class="kt">interface</span> <span class="nv">Human</span> : <span class="n">Animal</span> {
<span class="kt">attribute</span> <span class="n">Dog</span>? <span class="nv">pet</span>;
};
<span class="kt">interface</span> <span class="nv">Dog</span> : <span class="n">Animal</span> {
<span class="kt">attribute</span> <span class="n">Human</span>? <span class="nv">owner</span>;
};
</pre>
</div>
<div class="example" id="example-8796d516">
<a class="self-link" href="#example-8796d516"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-12">IDL fragment</a> defines
simplified versions of a few DOM <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-13">interfaces</a>, one of which
is a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-6">callback interface</a>.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Node</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">nodeName</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Node</span>? <span class="nv">parentNode</span>;
<span class="n">Node</span> <span class="nv">appendChild</span>(<span class="n">Node</span> <span class="nv">newChild</span>);
<span class="kt">void</span> <span class="nv">addEventListener</span>(<span class="kt">DOMString</span> <span class="nv">type</span>, <span class="n">EventListener</span> <span class="nv">listener</span>);
};
<span class="kt">callback</span> <span class="kt">interface</span> <span class="nv">EventListener</span> {
<span class="kt">void</span> <span class="nv">handleEvent</span>(<span class="n">Event</span> <span class="nv">event</span>);
};
</pre>
<p>Since the <code class="idl">EventListener</code> interface is annotated
callback interface, <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-3">user objects</a> can implement it:</p>
<pre class="highlight"><span class="kd">var</span> node <span class="o">=</span> getNode<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of Node.
</span>
<span class="kd">var</span> listener <span class="o">=</span> <span class="p">{</span>
handleEvent<span class="o">:</span> <span class="kd">function</span><span class="p">(</span>event<span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...
</span> <span class="p">}</span>
<span class="p">}</span><span class="p">;</span>
node<span class="p">.</span>addEventListener<span class="p">(</span><span class="s2">"click"</span><span class="p">,</span> listener<span class="p">)</span><span class="p">;</span> <span class="c1">// This works.
</span>
node<span class="p">.</span>addEventListener<span class="p">(</span><span class="s2">"click"</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> <span class="p">...</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span> <span class="c1">// As does this.
</span></pre>
<p>It is not possible for a user object to implement <code class="idl">Node</code>, however:</p>
<pre class="highlight"><span class="kd">var</span> node <span class="o">=</span> getNode<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of Node.
</span>
<span class="kd">var</span> newNode <span class="o">=</span> <span class="p">{</span>
nodeName<span class="o">:</span> <span class="s2">"span"</span><span class="p">,</span>
parentNode<span class="o">:</span> <span class="kc">null</span><span class="p">,</span>
appendChild<span class="o">:</span> <span class="kd">function</span><span class="p">(</span>newchild<span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...
</span> <span class="p">}</span><span class="p">,</span>
addEventListener<span class="o">:</span> <span class="kd">function</span><span class="p">(</span>type<span class="p">,</span> listener<span class="p">)</span> <span class="p">{</span>
<span class="c1">// ...
</span> <span class="p">}</span>
<span class="p">}</span><span class="p">;</span>
node<span class="p">.</span>appendChild<span class="p">(</span>newNode<span class="p">)</span><span class="p">;</span> <span class="c1">// This will throw a TypeError exception.
</span></pre>
</div>
<h4 class="heading settled" data-level="2.2.1" id="idl-constants"><span class="secno">2.2.1. </span><span class="content">Constants</span><a class="self-link" href="#idl-constants"></a></h4>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-constant">constant</dfn> is a declaration (matching <emu-nt><a href="#prod-Const">Const</a></emu-nt>) used to bind a constant value to a name.
Constants can appear on <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-14">interfaces</a>.</p>
<p class="advisement"> Constants have in the past primarily been used to define
named integer codes in the style of an enumeration. The Web platform
is moving away from this design pattern in favor of the use of strings.
Specification authors who wish to define constants are strongly advised to discuss
this on the <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a> mailing list before proceeding. </p>
<pre class="syntax highlight"><span class="kt">const</span> <span class="n">type</span> <span class="nv">constant_identifier</span> = 42;</pre>
<p>The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-10">identifier</a> of a <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-4">constant</a> must not be the same as the identifier
of another <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-2">interface member</a> defined on the same interface.
The identifier also must not
be “length”, “name” or “prototype”.</p>
<p class="note" role="note">Note: These three names are the names of properties that exist on all <emu-val>Function</emu-val> objects.</p>
<p>The type of a constant (matching <emu-nt><a href="#prod-ConstType">ConstType</a></emu-nt>)
must not be any type other than
a <a data-link-type="dfn" href="#dfn-primitive-type" id="ref-for-dfn-primitive-type-1">primitive type</a> or a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-1">nullable</a> primitive type.
If an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-11">identifier</a> is used,
it must reference a <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-6">typedef</a> whose type is a primitive type or a nullable primitive type.</p>
<p>The <emu-nt><a href="#prod-ConstValue">ConstValue</a></emu-nt> part of a
constant declaration gives the value of the constant, which can be
one of the two boolean literal tokens (<code>true</code> and <code>false</code>),
the <code>null</code> token, an <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token,
a <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token,
or one of the three special floating point constant values
(<code>-Infinity</code>, <code>Infinity</code> and <code>NaN</code>).</p>
<p class="note" role="note">Note: These values – in addition to strings and the empty sequence – can also be used to specify the <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-1">default value of a dictionary member</a> or <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-1">of an optional argument</a>. Note that strings and the
empty sequence <code>[]</code> cannot be used as the value of a <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-5">constant</a>.</p>
<p>The value of the boolean literal tokens <code>true</code> and <code>false</code> are the IDL <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-1">boolean</a></code> values <emu-val>true</emu-val> and <emu-val>false</emu-val>.</p>
<p>The value of an <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token is an integer
whose value is determined as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the sequence of characters matched by the <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token.</p>
<li data-md="">
<p>Let <var>sign</var> be −1 if <var>S</var> begins with <span class="char">U+002D HYPHEN-MINUS ("-")</span>, and 1 otherwise.</p>
<li data-md="">
<p>Let <var>base</var> be the base of the number based on the characters that follow the optional leading <span class="char">U+002D HYPHEN-MINUS ("-")</span> character:</p>
<dl class="switch">
<dt data-md="">
<p><span class="char">U+0030 DIGIT ZERO ("0")</span>, <span class="char">U+0058 LATIN CAPITAL LETTER X ("X")</span></p>
<dt data-md="">
<p><span class="char">U+0030 DIGIT ZERO ("0")</span>, <span class="char">U+0078 LATIN SMALL LETTER X ("x")</span></p>
<dd data-md="">
<p>The base is 16.</p>
<dt data-md="">
<p><span class="char">U+0030 DIGIT ZERO ("0")</span></p>
<dd data-md="">
<p>The base is 8.</p>
<dt data-md="">
<p><span class="char">Otherwise</span></p>
<dd data-md="">
<p>The base is 10.</p>
</dl>
<li data-md="">
<p>Let <var>number</var> be the result of interpreting all remaining characters following the optional leading <span class="char">U+002D HYPHEN-MINUS ("-")</span> character and any characters indicating the base as an integer specified in base <var>base</var>.</p>
<li data-md="">
<p>Return <var>sign</var> × <var>number</var>.</p>
</ol>
<p>The type of an <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token is the same
as the type of the constant, dictionary member or optional argument it is being used as the value of.
The value of the <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token must not
lie outside the valid range of values for its type, as given in <a href="#idl-types">§2.11 Types</a>.</p>
<p id="float-token-value"> The value of a <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token is
either an IEEE 754 single-precision floating point number or an IEEE 754
double-precision floating point number, depending on the type of the
constant, dictionary member or optional argument it is being used as the value for, determined as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the sequence of characters matched by the <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token.</p>
<li data-md="">
<p>Let <var>value</var> be the Mathematical Value that would be obtained if <var>S</var> were
parsed as an ECMAScript <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-literals-numeric-literals">NumericLiteral</a>.</p>
<li data-md="">
<p>If the <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token is being
used as the value for a <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-1">float</a></code> or <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-1">unrestricted float</a></code>, then
the value of the <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token
is the IEEE 754 single-precision floating point number closest to <var>result</var>. Otherwise, the <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token is being
used as the value for a <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-1">double</a></code> or <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-1">unrestricted double</a></code>, and
the value of the <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token
is the IEEE 754 double-precision floating point number closest to <var>result</var>. <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a></p>
</ol>
<p>The value of a constant value specified as <code>Infinity</code>, <code>-Infinity</code> or <code>NaN</code> is either
an IEEE 754 single-precision floating point number or an IEEE 754
double-precision floating point number, depending on the type of the
constant, dictionary member or optional argument is is being used as the
value for:</p>
<dl class="switch">
<dt data-md="">
<p>Type <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-2">unrestricted float</a></code>, constant value <code>Infinity</code></p>
<dd data-md="">
<p>The value is the IEEE 754 single-precision positive infinity value.</p>
<dt data-md="">
<p>Type <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-2">unrestricted double</a></code>, constant value <code>Infinity</code></p>
<dd data-md="">
<p>The value is the IEEE 754 double-precision positive infinity value.</p>
<dt data-md="">
<p>Type <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-3">unrestricted float</a></code>, constant value <code>-Infinity</code></p>
<dd data-md="">
<p>The value is the IEEE 754 single-precision negative infinity value.</p>
<dt data-md="">
<p>Type <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-3">unrestricted double</a></code>, constant value <code>-Infinity</code></p>
<dd data-md="">
<p>The value is the IEEE 754 double-precision negative infinity value.</p>
<dt data-md="">
<p>Type <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-4">unrestricted float</a></code>, constant value <code>NaN</code></p>
<dd data-md="">
<p>The value is the IEEE 754 single-precision NaN value with the bit pattern 0x7fc00000.</p>
<dt data-md="">
<p>Type <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-4">unrestricted double</a></code>, constant value <code>NaN</code></p>
<dd data-md="">
<p>The value is the IEEE 754 double-precision NaN value with the bit pattern 0x7ff8000000000000.</p>
</dl>
<p>The type of a <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token is the same
as the type of the constant, dictionary member or optional argument it is being used as the value of. The value of the <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token must not
lie outside the valid range of values for its type, as given in <a href="#idl-types">§2.11 Types</a>.
Also, <code>Infinity</code>, <code>-Infinity</code> and <code>NaN</code> must not
be used as the value of a <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-2">float</a></code> or <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-2">double</a></code>.</p>
<p>The value of the <code>null</code> token is the special <emu-val>null</emu-val> value that is a member of the <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-2">nullable types</a>. The type of
the <code>null</code> token is the same as the
type of the constant, dictionary member or optional argument it is being used as the value of.</p>
<p>If <var>VT</var> is the type of the value assigned to a constant, and <var>DT</var> is the type of the constant, dictionary member or optional argument itself, then these types must
be compatible, which is the case if <var>DT</var> and <var>VT</var> are identical,
or <var>DT</var> is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-3">nullable type</a> whose <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-1">inner type</a> is <var>VT</var>.</p>
<p><a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-6">Constants</a> are not associated with
particular instances of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-15">interface</a> on which they appear. It is language binding specific whether <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-7">constants</a> are exposed on instances.</p>
<div class="note" role="note">
<p>The ECMAScript language binding does however
allow <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-8">constants</a> to be accessed
through objects implementing the IDL <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-16">interfaces</a> on which the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-9">constants</a> are declared.
For example, with the following IDL:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">const</span> <span class="kt">short</span> <span class="nv">rambaldi</span> = 47;
};
</pre>
<p>the constant value can be accessed in ECMAScript either as <code>A.rambaldi</code> or <code>instanceOfA.rambaldi</code>.</p>
</div>
<p>The following extended attributes are applicable to constants:
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-3">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-3">SecureContext</a></code>].</p>
<pre class="grammar" id="prod-Const">Const :
"const" ConstType identifier "=" ConstValue ";"
</pre>
<pre class="grammar" id="prod-ConstValue">ConstValue :
BooleanLiteral
FloatLiteral
integer
"null"
</pre>
<pre class="grammar" id="prod-BooleanLiteral">BooleanLiteral :
"true"
"false"
</pre>
<pre class="grammar" id="prod-FloatLiteral">FloatLiteral :
float
"-Infinity"
"Infinity"
"NaN"
</pre>
<pre class="grammar" id="prod-ConstType">ConstType :
PrimitiveType Null
identifier Null
</pre>
<div class="example" id="example-0da53320">
<a class="self-link" href="#example-0da53320"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-13">IDL fragment</a> demonstrates how <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-10">constants</a> of the above types can be defined.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Util</span> {
<span class="kt">const</span> <span class="kt">boolean</span> <span class="nv">DEBUG</span> = <span class="kt">false</span>;
<span class="kt">const</span> <span class="kt">octet</span> <span class="nv">LF</span> = 10;
<span class="kt">const</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">BIT_MASK</span> = 0x0000fc00;
<span class="kt">const</span> <span class="kt">double</span> <span class="nv">AVOGADRO</span> = 6.022e23;
};
</pre>
</div>
<h4 class="heading settled" data-level="2.2.2" id="idl-attributes"><span class="secno">2.2.2. </span><span class="content">Attributes</span><a class="self-link" href="#idl-attributes"></a></h4>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-attribute">attribute</dfn> is an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-3">interface member</a> (matching <emu-t>inherit</emu-t> <emu-nt><a href="#prod-ReadOnly">ReadOnly</a></emu-nt> <emu-nt><a href="#prod-AttributeRest">AttributeRest</a></emu-nt>, <emu-t>static</emu-t> <emu-nt><a href="#prod-ReadOnly">ReadOnly</a></emu-nt> <emu-nt><a href="#prod-AttributeRest">AttributeRest</a></emu-nt>, <emu-t>stringifier</emu-t> <emu-nt><a href="#prod-ReadOnly">ReadOnly</a></emu-nt> <emu-nt><a href="#prod-AttributeRest">AttributeRest</a></emu-nt>,
or <emu-nt><a href="#prod-ReadOnly">ReadOnly</a></emu-nt> <emu-nt><a href="#prod-AttributeRest">AttributeRest</a></emu-nt>)
that is used to declare data fields with a given type and <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-12">identifier</a> whose value can
be retrieved and (in some cases) changed. There are two kinds of attributes:</p>
<ol>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-1">regular attributes</a>, which are those
used to declare that objects implementing the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-17">interface</a> will have a data field member with the given <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-13">identifier</a></p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">attribute</span> <span class="n">type</span> <span class="nv">identifier</span>;
};
</pre>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-2">static attributes</a>, which are used
to declare attributes that are not associated with a particular object implementing the interface</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">static</span> <span class="kt">attribute</span> <span class="n">type</span> <span class="nv">identifier</span>;
};
</pre>
</ol>
<p>If an attribute has no <code>static</code> keyword, then it declares a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-regular-attribute">regular attribute</dfn>. Otherwise,
it declares a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-3">static attribute</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-14">identifier</a> of an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-6">attribute</a> must not be the same as the identifier
of another <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-4">interface member</a> defined on the same <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-18">interface</a>.
The identifier of a static attribute must not
be “prototype”.</p>
<p>The type of the attribute is given by the type (matching <emu-nt><a href="#prod-Type">Type</a></emu-nt>)
that appears after the <code>attribute</code> keyword.
If the <emu-nt><a href="#prod-Type">Type</a></emu-nt> is an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-15">identifier</a> or an identifier followed by <code>?</code>,
then the identifier must
identify an interface, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-4">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-7">callback function</a> or <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-7">typedef</a>.</p>
<p>The type of the attribute, after resolving typedefs, must not be a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-4">nullable</a> or non-nullable version of any of the following types:</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-1">sequence type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-1">dictionary type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-1">union type</a> that has a nullable or non-nullable sequence type or dictionary
as one of its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-1">flattened member types</a></p>
</ul>
<p>The attribute is <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-read-only">read only</dfn> if the <code>readonly</code> keyword is used before the <code>attribute</code> keyword.
An object that implements the interface on which a read only attribute
is defined will not allow assignment to that attribute. It is language
binding specific whether assignment is simply disallowed by the language,
ignored or an exception is thrown.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">type</span> <span class="nv">identifier</span>;
};
</pre>
<p>A <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-2">regular attribute</a> that is not <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-2">read only</a> can be declared to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-inherit-getter">inherit its getter</dfn> from an ancestor interface. This can be used to make a read only attribute
in an ancestor interface be writable on a derived interface. An attribute <a data-link-type="dfn" href="#dfn-inherit-getter" id="ref-for-dfn-inherit-getter-1">inherits its getter</a> if
its declaration includes <code>inherit</code> in the declaration.
The read only attribute from which the attribute inherits its getter
is the attribute with the same identifier on the closest ancestor interface
of the one on which the inheriting attribute is defined. The attribute
whose getter is being inherited must be
of the same type as the inheriting attribute, and <code>inherit</code> must not appear on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-3">read only</a> attribute or a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-4">static attribute</a>.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">Ancestor</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">TheType</span> <span class="nv">theIdentifier</span>;
};
<span class="kt">interface</span> <span class="nv">Derived</span> : <span class="n">Ancestor</span> {
<span class="kt">inherit</span> <span class="kt">attribute</span> <span class="n">TheType</span> <span class="nv">theIdentifier</span>;
};
</pre>
<p>When the <code>stringifier</code> keyword is used
in a <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-3">regular attribute</a> declaration, it indicates that objects implementing the
interface will be stringified to the value of the attribute. See <a href="#idl-stringifiers">§2.2.4.2 Stringifiers</a> for details.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">stringifier</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">identifier</span>;
};
</pre>
<p id="callback-attribute-exceptions"> If an implementation attempts to get or set the value of an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-7">attribute</a> on a <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-4">user object</a> (for example, when a callback object has been supplied to the implementation),
and that attempt results in an exception being thrown, then, unless otherwise specified, that
exception will be propagated to the user code that caused the
implementation to access the attribute. Similarly, if a value
returned from getting the attribute cannot be converted to
an IDL type, then any exception resulting from this will also
be propagated to the user code that resulted in the implementation
attempting to get the value of the attribute. </p>
<p>The following <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-7">extended attributes</a> are applicable to regular and static attributes:
[<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-1">Clamp</a></code>],
[<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-1">EnforceRange</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-4">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SameObject" id="ref-for-SameObject-1">SameObject</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-4">SecureContext</a></code>],
[<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-1">TreatNullAs</a></code>].</p>
<p>The following <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-8">extended attributes</a> are applicable only to regular attributes:
[<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-1">LenientSetter</a></code>],
[<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-1">LenientThis</a></code>],
[<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-1">PutForwards</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-1">Replaceable</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-3">Unforgeable</a></code>].</p>
<pre class="grammar" id="prod-ReadOnlyMember">ReadOnlyMember :
"readonly" ReadOnlyMemberRest
</pre>
<pre class="grammar" id="prod-ReadOnlyMemberRest">ReadOnlyMemberRest :
AttributeRest
ReadWriteMaplike
ReadWriteSetlike
</pre>
<pre class="grammar" id="prod-ReadWriteAttribute">ReadWriteAttribute :
"inherit" ReadOnly AttributeRest
AttributeRest
</pre>
<pre class="grammar" id="prod-AttributeRest">AttributeRest :
"attribute" Type AttributeName ";"
</pre>
<pre class="grammar" id="prod-AttributeName">AttributeName :
AttributeNameKeyword
identifier
</pre>
<pre class="grammar" id="prod-AttributeNameKeyword">AttributeNameKeyword :
"required"
</pre>
<pre class="grammar" id="prod-Inherit">Inherit :
"inherit"
ε
</pre>
<pre class="grammar" id="prod-ReadOnly">ReadOnly :
"readonly"
ε
</pre>
<div class="example" id="example-d90ac809">
<a class="self-link" href="#example-d90ac809"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-14">IDL fragment</a> demonstrates how <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-8">attributes</a> can be declared on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-19">interface</a>:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Animal</span> {
// A simple attribute that can be set to any string value.
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
// An attribute whose value can be assigned to.
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">short</span> <span class="nv">age</span>;
};
<span class="kt">interface</span> <span class="nv">Person</span> : <span class="n">Animal</span> {
// An attribute whose getter behavior is inherited from Animal, and need not be
// specified in the description of Person.
<span class="kt">inherit</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
};
</pre>
</div>
<h4 class="heading settled" data-level="2.2.3" id="idl-operations"><span class="secno">2.2.3. </span><span class="content">Operations</span><a class="self-link" href="#idl-operations"></a></h4>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-operation">operation</dfn> is an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-5">interface member</a> (matching <emu-t>static</emu-t> <emu-nt><a href="#prod-OperationRest">OperationRest</a></emu-nt>, <emu-t>stringifier</emu-t> <emu-nt><a href="#prod-OperationRest">OperationRest</a></emu-nt>, <emu-t>serializer</emu-t> <emu-nt><a href="#prod-OperationRest">OperationRest</a></emu-nt>, <emu-nt><a href="#prod-ReturnType">ReturnType</a></emu-nt> <emu-nt><a href="#prod-OperationRest">OperationRest</a></emu-nt> or <emu-nt><a href="#prod-SpecialOperation">SpecialOperation</a></emu-nt>)
that defines a behavior that can be invoked on objects implementing the interface.
There are three kinds of operation:</p>
<ol>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-1">regular operations</a>, which
are those used to declare that objects implementing the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-20">interface</a> will have a method with
the given <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-16">identifier</a></p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">identifier</span>(/* arguments... */);
};
</pre>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-special-operation" id="ref-for-dfn-special-operation-2">special operations</a>,
which are used to declare special behavior on objects
implementing the interface, such as object indexing and stringification</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
/* special_keywords... */ <span class="n">return_type</span> <span class="nv">identifier</span>(/* arguments... */);
/* special_keywords... */ <span class="n">return_type</span> (/* arguments... */);
};
</pre>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-2">static operations</a>,
which are used to declare operations that are not associated with
a particular object implementing the interface</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">static</span> <span class="n">return_type</span> <span class="nv">identifier</span>(/* arguments... */);
};
</pre>
</ol>
<p>If an operation has an identifier but no <code>static</code> keyword, then it declares a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-regular-operation">regular operation</dfn>.
If the operation has one or more <a data-link-type="dfn" href="#dfn-special-keyword" id="ref-for-dfn-special-keyword-1">special keywords</a> used in its declaration (that is, any keyword matching <emu-nt><a href="#prod-Special">Special</a></emu-nt>, or
the <code>stringifier</code> keyword),
then it declares a special operation. A single operation can declare
both a regular operation and a special operation;
see <a href="#idl-special-operations">§2.2.4 Special operations</a> for details on special operations.
Note that in addition to being <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-6">interface members</a>,
regular operations can also be <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-1">namespace members</a>.</p>
<p>If an operation has no identifier,
then it must be declared to be a special operation
using one of the special keywords.</p>
<p>The identifier of a <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-2">regular operation</a> or <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-3">static operation</a> must not be the same as the identifier
of a <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-11">constant</a> or <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-9">attribute</a> defined on the same <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-21">interface</a>.
The identifier of a static operation must not be “prototype”.</p>
<p class="note" role="note">Note: The identifier can be the same
as that of another operation on the interface, however.
This is how operation overloading is specified.</p>
<p>The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-17">identifier</a> of a <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-4">static operation</a> also must not be the same as the identifier
of a <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-3">regular operation</a> defined on the same <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-22">interface</a>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-return-type">return type</dfn> of the operation is given
by the type (matching <emu-nt><a href="#prod-ReturnType">ReturnType</a></emu-nt>)
that appears before the operation’s optional <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-18">identifier</a>.
A return type of <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-void">void</dfn> indicates that the operation returns no value.
If the return type is an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-19">identifier</a> followed by <code>?</code>,
then the identifier must
identify an interface, dictionary, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-5">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-8">callback function</a> or <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-8">typedef</a>.</p>
<p>An operation’s arguments (matching <emu-nt><a href="#prod-ArgumentList">ArgumentList</a></emu-nt>)
are given between the parentheses in the declaration. Each individual argument is specified
as a type (matching <emu-nt><a href="#prod-Type">Type</a></emu-nt>) followed by an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-20">identifier</a> (matching <emu-nt><a href="#prod-ArgumentName">ArgumentName</a></emu-nt>).</p>
<p class="note" role="note">Note: For expressiveness, the identifier of an operation argument can also be specified
as one of the keywords matching the <emu-nt><a href="#prod-ArgumentNameKeyword">ArgumentNameKeyword</a></emu-nt> symbol without needing to escape it.</p>
<p>If the <emu-nt><a href="#prod-Type">Type</a></emu-nt> of an operation argument is an identifier
followed by <code>?</code>,
then the identifier must identify an interface, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-6">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-9">callback function</a> or <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-9">typedef</a>.
If the operation argument type is an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-21">identifier</a> not followed by <code>?</code>, then the identifier must
identify any one of those definitions or a <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-6">dictionary</a>.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">identifier</span>(<span class="n">type</span> <span class="nv">identifier</span>, <span class="n">type</span> <span class="nv">identifier</span> /* , ... */);
};
</pre>
<p>The identifier of each argument must not be the same
as the identifier of another argument in the same operation declaration.</p>
<p>Each argument can be preceded by a list of <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-9">extended attributes</a> (matching <emu-nt><a href="#prod-ExtendedAttributeList">ExtendedAttributeList</a></emu-nt>),
which can control how a value passed as the argument will be handled in
language bindings.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">identifier</span>([<mark><span class="nv">extended_attributes</span></mark>] <span class="n">type</span> <span class="nv">identifier</span>, [<mark><span class="nv">extended_attributes</span></mark>] <span class="n">type</span> <span class="nv">identifier</span> /* , ... */);
};
</pre>
<div class="example" id="example-1abbf295">
<a class="self-link" href="#example-1abbf295"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-15">IDL fragment</a> demonstrates how <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-4">regular operations</a> can be declared on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-23">interface</a>:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Dimensions</span> {
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">width</span>;
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">height</span>;
};
<span class="kt">interface</span> <span class="nv">Button</span> {
// An operation that takes no arguments and returns a boolean.
<span class="kt">boolean</span> <span class="nv">isMouseOver</span>();
// Overloaded operations.
<span class="kt">void</span> <span class="nv">setDimensions</span>(<span class="n">Dimensions</span> <span class="nv">size</span>);
<span class="kt">void</span> <span class="nv">setDimensions</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">width</span>, <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">height</span>);
};
</pre>
</div>
<p>An operation is considered to be <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-variadic">variadic</dfn> if the final argument uses the <code>...</code> token just
after the argument type. Declaring an operation to be variadic indicates that
the operation can be invoked with any number of arguments after that final argument.
Those extra implied formal arguments are of the same type as the final explicit
argument in the operation declaration. The final argument can also be omitted
when invoking the operation. An argument must not
be declared with the <code>...</code> token unless it
is the final argument in the operation’s argument list.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">identifier</span>(<span class="n">type</span><mark>...</mark> <span class="nv">identifier</span>);
<span class="n">return_type</span> <span class="nv">identifier</span>(<span class="n">type</span> <span class="nv">identifier</span>, <span class="n">type</span><mark>...</mark> <span class="nv">identifier</span>);
};
</pre>
<p><a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-10">Extended attributes</a> that <a data-link-type="dfn" href="#dfn-xattr-argument-list" id="ref-for-dfn-xattr-argument-list-1">take an argument list</a> ([<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-4">Constructor</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-3">NamedConstructor</a></code>], of those
defined in this specification) and <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-10">callback functions</a> are also considered to be <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-1">variadic</a> when the <code>...</code> token is used in their argument lists.</p>
<div class="example" id="example-20770917">
<a class="self-link" href="#example-20770917"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-16">IDL fragment</a> defines an interface that has
two variadic operations:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">IntegerSet</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">cardinality</span>;
<span class="kt">void</span> <span class="nv">union</span>(<span class="kt">long</span>... <span class="nv">ints</span>);
<span class="kt">void</span> <span class="nv">intersection</span>(<span class="kt">long</span>... <span class="nv">ints</span>);
};
</pre>
<p>In the ECMAScript binding, variadic operations are implemented by
functions that can accept the subsequent arguments:</p>
<pre class="highlight"><span class="kd">var</span> s <span class="o">=</span> getIntegerSet<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of IntegerSet.
</span>
s<span class="p">.</span>union<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Passing no arguments corresponding to 'ints'.
</span>s<span class="p">.</span>union<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">7</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Passing three arguments corresponding to 'ints'.
</span></pre>
<p>A binding for a language that does not support variadic functions
might specify that an explicit array or list of integers be passed
to such an operation.</p>
</div>
<p>An argument is considered to be an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-optional-argument">optional argument</dfn> if it is declared with the <code>optional</code> keyword.
The final argument of a <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-2">variadic</a> operation
is also considered to be an optional argument. Declaring an argument
to be optional indicates that the argument value can be omitted
when the operation is invoked. The final argument in an
operation must not explicitly be declared to be
optional if the operation is <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-3">variadic</a>.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">identifier</span>(<span class="n">type</span> <span class="nv">identifier</span>, <span class="kt">optional</span> <span class="n">type</span> <span class="nv">identifier</span>);
};
</pre>
<p>Optional arguments can also have a <dfn class="dfn-paneled" data-dfn-for="optional argument" data-dfn-type="dfn" data-export="" id="dfn-optional-argument-default-value">default value</dfn> specified. If the argument’s identifier is followed by a <span class="char">U+003D EQUALS SIGN ("=")</span> and a value (matching <emu-nt><a href="#prod-DefaultValue">DefaultValue</a></emu-nt>),
then that gives the optional argument its <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-2">default value</a>.
The implicitly optional final argument of a <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-4">variadic</a> operation must not have a default value specified.
The default value is the value to be assumed when the operation is called with the
corresponding argument omitted.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="n">return_type</span> <span class="nv">identifier</span>(<span class="n">type</span> <span class="nv">identifier</span>, <span class="kt">optional</span> <span class="n">type</span> <span class="nv">identifier</span> = "value");
};
</pre>
<p class="advisement"> It is strongly suggested not to use <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-3">default value</a> of <emu-val>true</emu-val> for <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-2">boolean</a></code>-typed arguments,
as this can be confusing for authors who might otherwise expect the default
conversion of <emu-val>undefined</emu-val> to be used (i.e., <emu-val>false</emu-val>). </p>
<p>If the type of an argument is a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-2">dictionary type</a> or a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-2">union type</a> that has a
dictionary type as one of its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-2">flattened member types</a>,
and that dictionary type and its ancestors have no <a data-link-type="dfn" href="#required-dictionary-member" id="ref-for-required-dictionary-member-1">required members</a>,
and the argument is either the final argument or is followed only by <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-1">optional arguments</a>, then
the argument must be specified as optional.
Such arguments are always considered to have a <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-4">default value</a> of an empty dictionary,
unless otherwise specified.</p>
<div class="note" role="note">
<p>This is to encourage API designs that do not require authors to pass an
empty dictionary value when they wish only to use the dictionary’s
default values.</p>
<p>Dictionary types cannot have a default value specified explicitly, so the
“unless otherwise specified” clause above can only be invoked for
a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-3">union type</a> that has a
dictionary type as one of its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-3">flattened member types</a>.</p>
</div>
<p>When a boolean literal token (<code>true</code> or <code>false</code>),
the <code>null</code> token,
an <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token, a <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token or one of
the three special floating point literal values (<code>Infinity</code>, <code>-Infinity</code> or <code>NaN</code>) is used as the <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-5">default value</a>,
it is interpreted in the same way as for a <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-12">constant</a>.</p>
<p id="string-literal"> Optional argument default values can also be specified using a <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> token, whose value is a <a data-link-type="dfn" href="#dfn-string-type" id="ref-for-dfn-string-type-1">string type</a> determined as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the sequence of <a data-link-type="dfn" href="http://www.unicode.org/glossary/#unicode_scalar_value">Unicode scalar values</a> matched by
the <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> token
with its leading and trailing <span class="char">U+0022 QUOTATION MARK ('"')</span> characters removed.</p>
<li data-md="">
<p>Depending on the type of the argument:</p>
<dl class="switch">
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-1">DOMString</a></code></p>
<dt data-md="">
<p>an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-7">enumeration</a> type</p>
<dd data-md="">
<p>The value of the <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> token
is the sequence of 16 bit unsigned integer code units
(hereafter referred to just as <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="dfn-code-unit">code units</dfn>)
corresponding to the UTF-16 encoding of <var>S</var>.</p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-1">ByteString</a></code></p>
<dd data-md="">
<p>The value of the <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> token
is the sequence of 8 bit unsigned integer code units
corresponding to the UTF-8 encoding of <var>S</var>.</p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-1">USVString</a></code></p>
<dd data-md="">
<p>The value of the <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> token is <var>S</var>.</p>
</dl>
</ol>
<p>If the type of the <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-2">optional argument</a> is an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-8">enumeration</a>, then its <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-6">default value</a> if specified must
be one of the <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-1">enumeration’s values</a>.</p>
<p>Optional argument default values can also be specified using the
two token value <code>[]</code>, which represents an empty sequence
value. The type of this value is the same the type of the optional
argument it is being used as the default value of. That type
must be a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-2">sequence type</a> or a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-5">nullable type</a>.</p>
<div class="example" id="example-42003e8b">
<a class="self-link" href="#example-42003e8b"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-17">IDL fragment</a> defines an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-24">interface</a> with a single <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-6">operation</a> that can be invoked with two different argument list lengths:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">ColorCreator</span> {
<span class="kt">object</span> <span class="nv">createColor</span>(<span class="kt">double</span> <span class="nv">v1</span>, <span class="kt">double</span> <span class="nv">v2</span>, <span class="kt">double</span> <span class="nv">v3</span>, <span class="kt">optional</span> <span class="kt">double</span> <span class="nv">alpha</span>);
};
</pre>
<p>It is equivalent to an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-25">interface</a> that has two <a data-link-type="dfn" href="#dfn-overloaded" id="ref-for-dfn-overloaded-1">overloaded</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-7">operations</a>:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">ColorCreator</span> {
<span class="kt">object</span> <span class="nv">createColor</span>(<span class="kt">double</span> <span class="nv">v1</span>, <span class="kt">double</span> <span class="nv">v2</span>, <span class="kt">double</span> <span class="nv">v3</span>);
<span class="kt">object</span> <span class="nv">createColor</span>(<span class="kt">double</span> <span class="nv">v1</span>, <span class="kt">double</span> <span class="nv">v2</span>, <span class="kt">double</span> <span class="nv">v3</span>, <span class="kt">double</span> <span class="nv">alpha</span>);
};
</pre>
</div>
<p id="callback-operation-exceptions"> If an implementation attempts to invoke
an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-8">operation</a> on a <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-5">user object</a> (for example, when a callback object has been supplied to the implementation),
and that attempt results in an exception being thrown, then,
unless otherwise specified,
that exception will be propagated to
the user code that caused the implementation to invoke the operation.
Similarly, if a value returned from invoking the operation
cannot be converted to an IDL type,
then any exception resulting from this will also
be propagated to the user code
that resulted in the implementation attempting to invoke the operation. </p>
<p>The following extended attributes are applicable to operations:
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-5">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#NewObject" id="ref-for-NewObject-1">NewObject</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-5">SecureContext</a></code>],
[<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-2">TreatNullAs</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-4">Unforgeable</a></code>].</p>
<p>The following extended attributes are applicable to operation arguments:
[<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-2">Clamp</a></code>],
[<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-2">EnforceRange</a></code>],
[<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-3">TreatNullAs</a></code>].</p>
<pre class="grammar" id="prod-DefaultValue">DefaultValue :
ConstValue
string
"[" "]"
</pre>
<pre class="grammar" id="prod-Operation">Operation :
ReturnType OperationRest
SpecialOperation
</pre>
<pre class="grammar" id="prod-SpecialOperation">SpecialOperation :
Special Specials ReturnType OperationRest
</pre>
<pre class="grammar" id="prod-Specials">Specials :
Special Specials
ε
</pre>
<pre class="grammar" id="prod-Special">Special :
"getter"
"setter"
"deleter"
"legacycaller"
</pre>
<pre class="grammar" id="prod-OperationRest">OperationRest :
OptionalIdentifier "(" ArgumentList ")" ";"
</pre>
<pre class="grammar" id="prod-OptionalIdentifier">OptionalIdentifier :
identifier
ε
</pre>
<pre class="grammar" id="prod-ArgumentList">ArgumentList :
Argument Arguments
ε
</pre>
<pre class="grammar" id="prod-Arguments">Arguments :
"," Argument Arguments
ε
</pre>
<pre class="grammar" id="prod-Argument">Argument :
ExtendedAttributeList OptionalOrRequiredArgument
</pre>
<pre class="grammar" id="prod-OptionalOrRequiredArgument">OptionalOrRequiredArgument :
"optional" Type ArgumentName Default
Type Ellipsis ArgumentName
</pre>
<pre class="grammar" id="prod-ArgumentName">ArgumentName :
ArgumentNameKeyword
identifier
</pre>
<pre class="grammar" id="prod-Ellipsis">Ellipsis :
"..."
ε
</pre>
<div data-fill-with="grammar-ArgumentNameKeyword"></div>
<pre class="grammar" id="prod-ReturnType">ReturnType :
Type
"void"
</pre>
<h4 class="heading settled" data-level="2.2.4" id="idl-special-operations"><span class="secno">2.2.4. </span><span class="content">Special operations</span><a class="self-link" href="#idl-special-operations"></a></h4>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-special-operation">special operation</dfn> is a
declaration of a certain kind of special behavior on objects implementing
the interface on which the special operation declarations appear.
Special operations are declared by using one or more <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-special-keyword">special keywords</dfn> in an operation declaration.</p>
<p>There are six kinds of special operations. The table below indicates
for a given kind of special operation what special keyword
is used to declare it and what the purpose of the special operation is:</p>
<table class="vert data">
<tbody>
<tr>
<th>Special operation
<th>Keyword
<th>Purpose
<tr>
<td><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="getter" id="dfn-getter">Getters</dfn>
<td><code>getter</code>
<td>Defines behavior for when an object is indexed for property retrieval.
<tr>
<td><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="setter" id="dfn-setter">Setters</dfn>
<td><code>setter</code>
<td>Defines behavior for when an object is indexed for property
assignment or creation.
<tr>
<td><dfn data-dfn-type="dfn" data-export="" data-lt="deleter" id="dfn-deleter">Deleters<a class="self-link" href="#dfn-deleter"></a></dfn>
<td><code>deleter</code>
<td>Defines behavior for when an object is indexed for property deletion.
<tr>
<td><dfn data-dfn-type="dfn" data-export="" data-lt="legacy" id="dfn-legacy-caller">Legacy callers<a class="self-link" href="#dfn-legacy-caller"></a></dfn>
<td><code>legacycaller</code>
<td>Defines behavior for when an object is called as if it were a function.
<tr>
<td><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="stringifier" id="dfn-stringifier">Stringifiers</dfn>
<td><code>stringifier</code>
<td>Defines how an object is converted into a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-2">DOMString</a></code>.
<tr>
<td><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="serializer" id="dfn-serializer">Serializers</dfn>
<td><code>serializer</code>
<td>Defines how an object is converted into a serialized form.
</table>
<p>Not all language bindings support all of the six kinds of special
object behavior. When special operations are declared using
operations with no identifier, then in language bindings that do
not support the particular kind of special operations there simply
will not be such functionality.</p>
<div class="example" id="example-7790d0b2">
<a class="self-link" href="#example-7790d0b2"></a>
<p>The following IDL fragment defines an interface with a getter and a setter:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Dictionary</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">propertyCount</span>;
<span class="kt">getter</span> <span class="kt">double</span> (<span class="kt">DOMString</span> <span class="nv">propertyName</span>);
<span class="kt">setter</span> <span class="kt">void</span> (<span class="kt">DOMString</span> <span class="nv">propertyName</span>, <span class="kt">double</span> <span class="nv">propertyValue</span>);
};
</pre>
<p>In language bindings that do not support property getters and setters,
objects implementing <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-7">Dictionary</a> will not
have that special behavior.</p>
</div>
<p>Defining a special operation with an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-22">identifier</a> is equivalent to separating the special operation out into its own
declaration without an identifier. This approach is allowed to
simplify prose descriptions of an interface’s operations.</p>
<div class="example" id="example-727aa798">
<a class="self-link" href="#example-727aa798"></a>
<p>The following two interfaces are equivalent:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Dictionary</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">propertyCount</span>;
<span class="kt">getter</span> <span class="kt">double</span> <span class="nv">getProperty</span>(<span class="kt">DOMString</span> <span class="nv">propertyName</span>);
<span class="kt">setter</span> <span class="kt">void</span> <span class="nv">setProperty</span>(<span class="kt">DOMString</span> <span class="nv">propertyName</span>, <span class="kt">double</span> <span class="nv">propertyValue</span>);
};
</pre>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Dictionary</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">propertyCount</span>;
<span class="kt">double</span> <span class="nv">getProperty</span>(<span class="kt">DOMString</span> <span class="nv">propertyName</span>);
<span class="kt">void</span> <span class="nv">setProperty</span>(<span class="kt">DOMString</span> <span class="nv">propertyName</span>, <span class="kt">double</span> <span class="nv">propertyValue</span>);
<span class="kt">getter</span> <span class="kt">double</span> (<span class="kt">DOMString</span> <span class="nv">propertyName</span>);
<span class="kt">setter</span> <span class="kt">void</span> (<span class="kt">DOMString</span> <span class="nv">propertyName</span>, <span class="kt">double</span> <span class="nv">propertyValue</span>);
};
</pre>
</div>
<p>A given <a data-link-type="dfn" href="#dfn-special-keyword" id="ref-for-dfn-special-keyword-2">special keyword</a> must not
appear twice on an operation.</p>
<p>Getters and setters come in two varieties: ones that
take a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-3">DOMString</a></code> as a property name,
known as <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="named property getter" id="dfn-named-property-getter">named property getters</dfn> and <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="named property setter" id="dfn-named-property-setter">named property setters</dfn>,
and ones that take an <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-2">unsigned long</a></code> as a property index, known as <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="indexed property getter" id="dfn-indexed-property-getter">indexed property getters</dfn> and <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="indexed property setter" id="dfn-indexed-property-setter">indexed property setters</dfn>.
There is only one variety of deleter: <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="named property deleter" id="dfn-named-property-deleter">named property deleters</dfn>.
See <a href="#idl-indexed-properties" id="ref-for-idl-indexed-properties-1">§2.2.4.4 Indexed properties</a> and <a href="#idl-named-properties" id="ref-for-idl-named-properties-1">§2.2.4.5 Named properties</a> for details.</p>
<p>On a given <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-26">interface</a>,
there must exist at most one
stringifier, at most one serializer, at most one <a data-link-type="dfn" href="#dfn-named-property-deleter" id="ref-for-dfn-named-property-deleter-1">named property deleter</a>,
and at most one of each variety of getter and setter.
Multiple legacy callers can exist on an interface
to specify overloaded calling behavior.</p>
<p>If an interface has a setter of a given variety,
then it must also have a getter of that
variety. If it has a <a data-link-type="dfn" href="#dfn-named-property-deleter" id="ref-for-dfn-named-property-deleter-2">named property deleter</a>,
then it must also have a <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-1">named property getter</a>.</p>
<p>Special operations declared using operations must not
be <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-5">variadic</a> nor have any <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-3">optional arguments</a>.</p>
<p>Special operations must not be declared on <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-7">callback interfaces</a>.</p>
<p>If an object implements more than one <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-27">interface</a> that defines a given special operation, then it is undefined which (if any)
special operation is invoked for that operation.</p>
<h5 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="2.2.4.1" data-lt="Legacy callers" data-noexport="" id="idl-legacy-callers"><span class="secno">2.2.4.1. </span><span class="content">Legacy callers</span></h5>
<p>When an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-28">interface</a> has one or more <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-1">legacy callers</a>, it indicates that objects that implement
the interface can be called as if they were functions. As mentioned above,
legacy callers can be specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-9">operation</a> declared with the <code>legacycaller</code> keyword.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">legacycaller</span> <span class="n">return_type</span> <span class="nv">identifier</span>(/* arguments... */);
<span class="kt">legacycaller</span> <span class="n">return_type</span> (/* arguments... */);
};
</pre>
<p>If multiple legacy callers are specified on an interface, overload resolution
is used to determine which legacy caller is invoked when the object is called
as if it were a function.</p>
<p>Legacy callers must not be defined to return a <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-1">promise type</a>.</p>
<p class="advisement"> Legacy callers are universally recognised as an undesirable feature. They exist
only so that legacy Web platform features can be specified. Legacy callers
should not be used in specifications unless required to
specify the behavior of legacy APIs, and even then this should be discussed on
the <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a> mailing list before proceeding. </p>
<div class="example" id="example-bd88c721">
<a class="self-link" href="#example-bd88c721"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-18">IDL fragment</a> defines an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-29">interface</a> with a <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-2">legacy caller</a>.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">NumberQuadrupler</span> {
// This operation simply returns four times the given number x.
<span class="kt">legacycaller</span> <span class="kt">double</span> <span class="nv">compute</span>(<span class="kt">double</span> <span class="nv">x</span>);
};
</pre>
<p>An ECMAScript implementation supporting this interface would
allow a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-2">platform object</a> that implements <code class="idl">NumberQuadrupler</code> to be called as a function:</p>
<pre class="highlight"><span class="kd">var</span> f <span class="o">=</span> getNumberQuadrupler<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of NumberQuadrupler.
</span>
f<span class="p">.</span>compute<span class="p">(</span><span class="mi">3</span><span class="p">)</span><span class="p">;</span> <span class="c1">// This evaluates to 12.
</span>f<span class="p">(</span><span class="mi">3</span><span class="p">)</span><span class="p">;</span> <span class="c1">// This also evaluates to 12.
</span></pre>
</div>
<h5 class="heading settled" data-level="2.2.4.2" id="idl-stringifiers"><span class="secno">2.2.4.2. </span><span class="content">Stringifiers</span><a class="self-link" href="#idl-stringifiers"></a></h5>
<p>When an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-30">interface</a> has a <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-1">stringifier</a>, it indicates that objects that implement
the interface have a non-default conversion to a string. As mentioned above,
stringifiers can be specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-10">operation</a> declared with the <code>stringifier</code> keyword.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">stringifier</span> <span class="kt">DOMString</span> <span class="nv">identifier</span>();
<span class="kt">stringifier</span> <span class="kt">DOMString</span> ();
};
</pre>
<p>If an operation used to declare a stringifier does not have an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-23">identifier</a>, then prose
accompanying the interface must define
the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-stringification-behavior">stringification behavior</dfn> of the interface. If the operation does have an identifier,
then the object is converted to a string by invoking the
operation to obtain the string.</p>
<p>Stringifiers declared with operations must
be declared to take zero arguments and return a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-4">DOMString</a></code>.</p>
<p>As a shorthand, if the <code>stringifier</code> keyword
is declared using an operation with no identifier, then the
operation’s <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-1">return type</a> and
argument list can be omitted.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">stringifier</span>;
};
</pre>
<div class="example" id="example-0cd98c47">
<a class="self-link" href="#example-0cd98c47"></a>
<p>The following two interfaces are equivalent:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">stringifier</span> <span class="kt">DOMString</span> ();
};
</pre>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">stringifier</span>;
};
</pre>
</div>
<p>The <code>stringifier</code> keyword
can also be placed on an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-10">attribute</a>.
In this case, the string to convert the object to is the
value of the attribute. The <code>stringifier</code> keyword
must not be placed on an attribute unless
it is declared to be of type <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-5">DOMString</a></code> or <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-2">USVString</a></code>.
It also must not be placed on
a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-5">static attribute</a>.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">stringifier</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">identifier</span>;
};
</pre>
<pre class="grammar" id="prod-Stringifier">Stringifier :
"stringifier" StringifierRest
</pre>
<pre class="grammar" id="prod-StringifierRest">StringifierRest :
ReadOnly AttributeRest
ReturnType OperationRest
";"
</pre>
<div class="example" id="example-1ad1cab1">
<a class="self-link" href="#example-1ad1cab1"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-19">IDL fragment</a> defines an interface that will stringify to the value of its <code class="idl">name</code> attribute:</p>
<pre class="highlight">[<span class="nv">Constructor</span>]
<span class="kt">interface</span> <span class="nv">Student</span> {
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">id</span>;
<span class="kt">stringifier</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
};
</pre>
<p>In the ECMAScript binding, using a <code class="idl">Student</code> object in a context where a string is expected will result in the
value of the object’s “name” property being
used:</p>
<pre class="highlight"><span class="kd">var</span> s <span class="o">=</span> <span class="k">new</span> Student<span class="p">(</span><span class="p">)</span><span class="p">;</span>
s<span class="p">.</span>id <span class="o">=</span> <span class="mi">12345678</span><span class="p">;</span>
s<span class="p">.</span>name <span class="o">=</span> <span class="s1">'周杰倫'</span><span class="p">;</span>
<span class="kd">var</span> greeting <span class="o">=</span> <span class="s1">'Hello, '</span> <span class="o">+</span> s <span class="o">+</span> <span class="s1">'!'</span><span class="p">;</span> <span class="c1">// Now greeting == 'Hello, 周杰倫!'.
</span></pre>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-20">IDL fragment</a> defines an interface that has custom stringification behavior that is
not specified in the IDL itself.</p>
<pre class="highlight">[<span class="nv">Constructor</span>]
<span class="kt">interface</span> <span class="nv">Student</span> {
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">id</span>;
<span class="kt">attribute</span> <span class="kt">DOMString</span>? <span class="nv">familyName</span>;
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">givenName</span>;
<span class="kt">stringifier</span> <span class="kt">DOMString</span> ();
};
</pre>
<p>Thus, prose is required to explain the stringification behavior, such
as the following paragraph:</p>
<blockquote>
<p>Objects that implement the <code class="idl">Student</code> interface must stringify as follows. If the value of the <code class="idl">familyName</code> attribute is <emu-val>null</emu-val>, the stringification of the
object is the value of the <code class="idl">givenName</code> attribute. Otherwise, if the value of the <code class="idl">familyName</code> attribute is not <emu-val>null</emu-val>,
the stringification of the object is the concatenation of the
value of the <code class="idl">givenName</code> attribute,
a single space character, and the value of
the <code class="idl">familyName</code> attribute.</p>
</blockquote>
<p>An ECMAScript implementation of the IDL would behave as follows:</p>
<pre class="highlight"><span class="kd">var</span> s <span class="o">=</span> <span class="k">new</span> Student<span class="p">(</span><span class="p">)</span><span class="p">;</span>
s<span class="p">.</span>id <span class="o">=</span> <span class="mi">12345679</span><span class="p">;</span>
s<span class="p">.</span>familyName <span class="o">=</span> <span class="s1">'Smithee'</span><span class="p">;</span>
s<span class="p">.</span>givenName <span class="o">=</span> <span class="s1">'Alan'</span><span class="p">;</span>
<span class="kd">var</span> greeting <span class="o">=</span> <span class="s1">'Hi '</span> <span class="o">+</span> s<span class="p">;</span> <span class="c1">// Now greeting == 'Hi Alan Smithee'.
</span></pre>
</div>
<h5 class="heading settled" data-level="2.2.4.3" id="idl-serializers"><span class="secno">2.2.4.3. </span><span class="content">Serializers</span><a class="self-link" href="#idl-serializers"></a></h5>
<p>When an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-31">interface</a> has a <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-1">serializer</a>, it indicates that objects provide
a way for them to be converted into a serialized form. Serializers can be declared
using the <code>serializer</code> keyword:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span>;
};
</pre>
<p>Prose accompanying an interface that declares a serializer in this
way must define the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-serialization-behavior">serialization behavior</dfn> of the interface. Serialization behavior is defined as returning
a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-serialized-value">serialized value</dfn> of one of the following types:</p>
<ul>
<li data-md="">
<p>a <em>map</em> of key–value pairs, where the keys are <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-6">DOMString</a></code> values (unique in the map) and the
values are <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-1">serialized values</a></p>
<li data-md="">
<p>a <em>list</em> of <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-2">serialized values</a></p>
<li data-md="">
<p>a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-7">DOMString</a></code> value</p>
<li data-md="">
<p>an <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-5">unrestricted double</a></code> value</p>
<li data-md="">
<p>a <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-3">boolean</a></code> value</p>
<li data-md="">
<p>the <emu-val>null</emu-val> value</p>
</ul>
<p>How the <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-1">serialization behavior</a> is made available on an object in a language binding, and how exactly the abstract <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-3">serialized value</a> is converted into
an appropriate concrete value, is language binding specific.</p>
<p class="note" role="note">Note: In the ECMAScript language binding, <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-2">serialization behavior</a> is exposed as a <code>toJSON</code> method which returns the <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-4">serialized value</a> converted
into an ECMAScript value that can be serialized to JSON by the <code>JSON.stringify</code> function. See <a href="#es-serializer">§3.6.7.2 Serializers</a> for details.</p>
<p><a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-3">Serialization behavior</a> can also be specified directly in IDL, rather than separately as prose.
This is done by following the <code>serializer</code> keyword with
a <span class="char">U+003D EQUALS SIGN ("=")</span> character and
a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-serialization-pattern">serialization pattern</dfn>,
which can take one of the following six forms:</p>
<ul>
<li data-md="">
<p>A map with entries corresponding to zero or more attributes from the interface, and optionally
attributes from an inherited interface:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> = { attribute_identifier, attribute_identifier /* , ... */ };
<span class="kt">serializer</span> = { <span class="kt">inherit</span>, attribute_identifier, attribute_identifier /* , ... */ };
};
</pre>
<p>Each identifier must be the identifier of an attribute declared
on the interface. The identified attributes all must have a <a data-link-type="dfn" href="#dfn-serializable-type" id="ref-for-dfn-serializable-type-1">serializable type</a>.</p>
<p>The <code>inherit</code> keyword must not be used unless
the interface inherits from another that defines a serializer, and the closest such interface
defines its serializer using this <a data-link-type="dfn" href="#dfn-serialization-pattern" id="ref-for-dfn-serialization-pattern-1">serialization pattern</a> form or the following form (i.e. <code>{ attribute }</code>).</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-4">serialization behavior</a> for this
form of serialization pattern is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>map</var> be an empty map.</p>
<li data-md="">
<p>If the <code>inherit</code> keyword was used, then set <var>map</var> to be the result of
the <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-5">serialization behavior</a> of the
closest inherited interface that declares a serializer.</p>
<li data-md="">
<p>For each attribute identifier <var>i</var> in the serialization pattern, in order:</p>
<ol>
<li data-md="">
<p>Remove any entry in <var>map</var> with key name <var>i</var>.</p>
<li data-md="">
<p>Let <var>V</var> be the value of the attribute with identifier <var>i</var>.</p>
<li data-md="">
<p>Add an entry to <var>map</var> whose key name is <var>i</var> and whose
value is result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-1">converting</a> <var>V</var> to a serialized value.</p>
</ol>
<li data-md="">
<p>Return <var>map</var>.</p>
</ol>
<li data-md="">
<p>A map with entries corresponding to all attributes from the interface that have
a <a data-link-type="dfn" href="#dfn-serializable-type" id="ref-for-dfn-serializable-type-2">serializable type</a>, and optionally
attributes from an inherited interface:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> = { <span class="kt">attribute</span> };
<span class="kt">serializer</span> = { <span class="kt">inherit</span>, <span class="kt">attribute</span> };
};
</pre>
<p>The <code>inherit</code> keyword must not be used unless
the interface inherits from another that defines a serializer, and the closest such interface
defines its serializer using this <a data-link-type="dfn" href="#dfn-serialization-pattern" id="ref-for-dfn-serialization-pattern-2">serialization pattern</a> form or the previous form.</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-6">serialization behavior</a> for this
form of serialization pattern is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>map</var> be an empty map.</p>
<li data-md="">
<p>If the <code>inherit</code> keyword was used, then set <var>map</var> to be the result of
the <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-7">serialization behavior</a> of the
closest inherited interface that declares a serializer.</p>
<li data-md="">
<p>For each identifier <var>i</var> of an attribute on the interface whose type is
a <a data-link-type="dfn" href="#dfn-serializable-type" id="ref-for-dfn-serializable-type-3">serializable type</a>, in the order they appear
on the interface:</p>
<ol>
<li data-md="">
<p>Remove any entry in <var>map</var> with key name <var>i</var>.</p>
<li data-md="">
<p>Let <var>V</var> be the value of the attribute with identifier <var>i</var>.</p>
<li data-md="">
<p>Add an entry to <var>map</var> whose key name is <var>i</var> and whose
value is result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-2">converting</a> <var>V</var> to a serialized value.</p>
</ol>
<li data-md="">
<p>Return <var>map</var>.</p>
</ol>
<li data-md="">
<p>A map with entries corresponding to the named properties:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> = { <span class="kt">getter</span> };
};
</pre>
<p>This form must not be used unless the interface or one it
inherits from supports named properties and the return type of the named property getter
is a serializable type.</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-8">serialization behavior</a> for this
form of serialization pattern is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>map</var> be an empty map.</p>
<li data-md="">
<p>For each supported property name <var>n</var> on the object, in order:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the value of the named property with name <var>n</var>.</p>
<li data-md="">
<p>Add an entry to <var>map</var> whose key name is <var>i</var> and whose
value is result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-3">converting</a> <var>V</var> to a serialized value.</p>
</ol>
<li data-md="">
<p>Return <var>map</var>.</p>
</ol>
<li data-md="">
<p>A list of value of zero or more attributes on the interface:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> = [ attribute_identifier, attribute_identifier /* , ... */ ];
};
</pre>
<p>Each identifier must be the identifier of an attribute declared
on the interface. The identified attributes all must have a <a data-link-type="dfn" href="#dfn-serializable-type" id="ref-for-dfn-serializable-type-4">serializable type</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-9">serialization behavior</a> for this
form of serialization pattern is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>list</var> be an empty list.</p>
<li data-md="">
<p>For each attribute identifier <var>i</var> in the serialization pattern:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the value of the attribute with identifier <var>i</var>.</p>
<li data-md="">
<p>Append to <var>list</var> the value that is the result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-4">converting</a> <var>V</var> to a serialized value.</p>
</ol>
<li data-md="">
<p>Return <var>list</var>.</p>
</ol>
<li data-md="">
<p>A list with entries corresponding to the indexed properties:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> = [ <span class="kt">getter</span> ];
};
</pre>
<p>This form must not be used unless the interface or one it
inherits from supports indexed properties and the return type of the indexed property getter
is a serializable type.</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-10">serialization behavior</a> for this
form of serialization pattern is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>list</var> be an empty list.</p>
<li data-md="">
<p>Let <var>i</var> be 0.</p>
<li data-md="">
<p>While <var>i</var> is less than or equal to the greatest supported property index on the object:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the value of the indexed property with index <var>i</var> if <var>i</var> is a supported property index, or <emu-val>null</emu-val> otherwise.</p>
<li data-md="">
<p>Append to <var>list</var> the value that is the result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-5">converting</a> <var>V</var> to a serialized value.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Return <var>map</var>.</p>
</ol>
<li data-md="">
<p>A single attribute:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> = attribute_identifier;
};
</pre>
<p>The identifier must be the identifier of an attribute declared
on the interface, and this attribute must have a <a data-link-type="dfn" href="#dfn-serializable-type" id="ref-for-dfn-serializable-type-5">serializable type</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-11">serialization behavior</a> for this
form of serialization pattern is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>V</var> be the value of the attribute with the specified identifier.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-6">converting</a> <var>V</var> to a serialized value.</p>
</ol>
</ul>
<p class="note" role="note">Note: Entries are added to maps in a particular order so that in the ECMAScript language binding
it is defined what order properties are added to objects. This is because this order
can influence the serialization that <code>JSON.stringify</code> can produce.</p>
<p>The list of <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="serializable type" id="dfn-serializable-type">serializable types</dfn> and how they are <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="converted to a serialized value|converted to serialized values" id="dfn-convert-to-serialized-value">converted to serialized values</dfn> is as follows:</p>
<dl class="switch">
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-1">long long</a></code></p>
<dd data-md="">
<p>converted by choosing the closest equivalent <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-3">double</a></code> value
(as when <a href="#es-long-long">converting a <code class="idl">long long</code> to an ECMAScript <emu-val>Number</emu-val> value</a>)</p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-1">unsigned long long</a></code></p>
<dd data-md="">
<p>converted by choosing the closest equivalent <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-4">double</a></code> value
(as when <a href="#es-unsigned-long-long">converting a <code class="idl">unsigned long long</code> to an ECMAScript <emu-val>Number</emu-val> value</a>)</p>
<dt data-md="">
<p>any other <a data-link-type="dfn" href="#dfn-integer-type" id="ref-for-dfn-integer-type-1">integer type</a></p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-3">float</a></code></p>
<dd data-md="">
<p>converted by choosing the equivalent <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-5">double</a></code> value</p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-6">double</a></code></p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-4">boolean</a></code></p>
<dt data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-8">DOMString</a></code></p>
<dd data-md="">
<p>the same value of the respective type</p>
<dt data-md="">
<p>an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-9">enumeration type</a></p>
<dd data-md="">
<p>the equivalent <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-9">DOMString</a></code> value</p>
<dt data-md="">
<p>a <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-3">USVString</a></code></p>
<dd data-md="">
<p>the <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-10">DOMString</a></code> produced by
encoding the given sequence of <a data-link-type="dfn" href="http://www.unicode.org/glossary/#unicode_scalar_value">Unicode scalar values</a> in
UTF-16</p>
<dt data-md="">
<p>a <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-2">ByteString</a></code></p>
<dd data-md="">
<p>the equivalent <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-11">DOMString</a></code> value where each code unit has the same value as the corresponding byte value</p>
<dt data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-6">nullable</a> serializable type</p>
<dd data-md="">
<p>converted to <emu-val>null</emu-val> if that is its value,
otherwise converted as per its <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-2">inner type</a></p>
<dt data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-4">union type</a> where all of its <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-1">member types</a> are serializable types</p>
<dd data-md="">
<p>converted as per its <a data-link-type="dfn" href="#dfn-specific-type" id="ref-for-dfn-specific-type-1">specific type</a></p>
<dt data-md="">
<p>a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-3">sequence type</a> that has a serializable type as its element type</p>
<dd data-md="">
<p>converted to a list where each element is the result of converting its
corresponding sequence element to a serialized value</p>
<dt data-md="">
<p>a <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-8">dictionary</a> where all of its <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-3">members</a> have serializable types</p>
<dd data-md="">
<p>converted to a map consisting of an entry for each dictionary member
that is present, where the entry’s key is the identifier of the dictionary
member and its value is the result of converting the dictionary member’s
value to a serializable type</p>
<dt data-md="">
<p>an <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-1">interface type</a> that has a <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-2">serializer</a></p>
<dd data-md="">
<p>converted by invoking the object’s serializer</p>
</dl>
<p>Serializers can also be specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-11">operation</a> with the <code>serializer</code> keyword:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">serializer</span> <span class="nv">identifier</span>();
};
</pre>
<p>Serializers declared with operations must
be declared to take zero arguments and return a <a data-link-type="dfn" href="#dfn-serializable-type" id="ref-for-dfn-serializable-type-6">serializable type</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-12">serialization behavior</a> of the interface with a serializer declared with an operation is the result of <a data-link-type="dfn" href="#dfn-convert-to-serialized-value" id="ref-for-dfn-convert-to-serialized-value-7">converting</a> the value returned from invoking the operation to a serialized value.</p>
<pre class="grammar" id="prod-Serializer">Serializer :
"serializer" SerializerRest
</pre>
<pre class="grammar" id="prod-SerializerRest">SerializerRest :
OperationRest
"=" SerializationPattern ";"
";"
</pre>
<pre class="grammar" id="prod-SerializationPattern">SerializationPattern :
"{" SerializationPatternMap "}"
"[" SerializationPatternList "]"
identifier
</pre>
<pre class="grammar" id="prod-SerializationPatternMap">SerializationPatternMap :
"getter"
"inherit" Identifiers
identifier Identifiers
ε
</pre>
<pre class="grammar" id="prod-SerializationPatternList">SerializationPatternList :
"getter"
identifier Identifiers
ε
</pre>
<pre class="grammar" id="prod-Identifiers">Identifiers :
"," identifier Identifiers
ε
</pre>
<div class="example" id="example-641a6dbb">
<a class="self-link" href="#example-641a6dbb"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-21">IDL fragment</a> defines
an interface <code class="idl">Transaction</code> that has a <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-3">serializer</a> defines in prose:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Transaction</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Account</span> <span class="nv">from</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Account</span> <span class="nv">to</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">amount</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">description</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">number</span>;
<span class="kt">serializer</span>;
};
<span class="kt">interface</span> <span class="nv">Account</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">number</span>;
};
</pre>
<p>The serializer could be defined as follows:</p>
<blockquote>
<p>The <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-13">serialization behavior</a> of the <code class="idl">Transaction</code> interface is to run the following
algorithm, where <var>O</var> is the object that implements <code class="idl">Transaction</code>:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>map</var> be an empty map.</p>
<li data-md="">
<p>Add an entry to <var>map</var> whose key is “from” and whose value is
the <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-5">serialized value</a> of
the <code>number</code> attribute on the <code class="idl">Account</code> object referenced by the <code>from</code> attribute on <var>O</var>.</p>
<li data-md="">
<p>Add an entry to <var>map</var> whose key is “to” and whose value is
the <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-6">serialized value</a> of
the <code>number</code> attribute on the <code class="idl">Account</code> object referenced by the <code>from</code> attribute on <var>O</var>.</p>
<li data-md="">
<p>For both of the attributes <code>amount</code> and <code>description</code>,
add an entry to <var>map</var> whose key is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-24">identifier</a> of the attribute
and whose value is the <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-7">serialized value</a> of the value of the attribute on <var>O</var>.</p>
<li data-md="">
<p>Return <var>map</var>.</p>
</ol>
</blockquote>
<p>If it was acceptable for <code class="idl">Account</code> objects to be serializable
on their own, then <a data-link-type="dfn" href="#dfn-serialization-pattern" id="ref-for-dfn-serialization-pattern-3">serialization patterns</a> could be used to avoid having to define the <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-14">serialization behavior</a> in prose:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Transaction</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Account</span> <span class="nv">from</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Account</span> <span class="nv">to</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">amount</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">description</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">number</span>;
<span class="kt">serializer</span> = { from, to, amount, description };
};
<span class="kt">interface</span> <span class="nv">Account</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">number</span>;
<span class="kt">serializer</span> = number;
};
</pre>
<p>In the ECMAScript language binding, there would exist a <code>toJSON</code> method on <code class="idl">Transaction</code> objects:</p>
<pre class="highlight"><span class="c1">// Get an instance of Transaction.
</span><span class="kd">var</span> txn <span class="o">=</span> getTransaction<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Evaluates to an object like this:
</span><span class="c1">// {
</span><span class="c1">// from: 1234
</span><span class="c1">// to: 5678
</span><span class="c1">// amount: 110.75
</span><span class="c1">// description: "dinner"
</span><span class="c1">// }
</span>txn<span class="p">.</span>toJSON<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Evaluates to a string like this:
</span><span class="c1">// '{"from":1234,"to":5678,"amount":110.75,"description":"dinner"}'
</span>JSON<span class="p">.</span>stringify<span class="p">(</span>txn<span class="p">)</span><span class="p">;</span>
</pre>
</div>
<h5 class="heading settled dfn-paneled" data-dfn-type="dfn" data-export="" data-level="2.2.4.4" data-lt="Indexed properties" id="idl-indexed-properties"><span class="secno">2.2.4.4. </span><span class="content">Indexed properties</span></h5>
<p>An <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-32">interface</a> that defines
an <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-1">indexed property getter</a> is said to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-support-indexed-properties">support indexed properties</dfn>.</p>
<p>If an interface <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-1">supports indexed properties</a>,
then the interface definition must be accompanied by
a description of what indices the object can be indexed with at
any given time. These indices are called the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-supported-property-indices">supported property indices</dfn>.</p>
<p>Indexed property getters must
be declared to take a single <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-3">unsigned long</a></code> argument.
Indexed property setters must
be declared to take two arguments, where the first is an <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-4">unsigned long</a></code>.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">getter</span> <span class="n">type</span> <span class="nv">identifier</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">identifier</span>);
<span class="kt">setter</span> <span class="n">type</span> <span class="nv">identifier</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">identifier</span>, <span class="n">type</span> <span class="nv">identifier</span>);
<span class="kt">getter</span> <span class="n">type</span> (<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">identifier</span>);
<span class="kt">setter</span> <span class="n">type</span> (<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">identifier</span>, <span class="n">type</span> <span class="nv">identifier</span>);
};
</pre>
<p>The following requirements apply to the definitions of indexed property getters and setters:</p>
<ul>
<li data-md="">
<p>If an <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-2">indexed property getter</a> was specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-12">operation</a> with an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-25">identifier</a>,
then the value returned when indexing the object with a given <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-1">supported property index</a> is the value that would be returned by invoking the operation, passing
the index as its only argument. If the operation used to declare the indexed property getter
did not have an identifier, then the interface definition must be accompanied
by a description of how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-determine-the-value-of-an-indexed-property">determine the value of an indexed property</dfn> for a given index.</p>
<li data-md="">
<p>If an <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-1">indexed property setter</a> was specified using an operation
with an identifier,
then the behavior that occurs when indexing the object for property assignment with a given supported property index and value
is the same as if the operation is invoked, passing
the index as the first argument and the value as the second argument. If the operation used to declare the indexed property setter
did not have an identifier, then the interface definition must be accompanied
by a description of how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-set-the-value-of-an-existing-indexed-property">set the value of an existing indexed property</dfn> and how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-set-the-value-of-a-new-indexed-property">set the value of a new indexed property</dfn> for a given property index and value.</p>
</ul>
<div class="note" role="note">
<p>Note that if an <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-3">indexed property getter</a> or <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-2">setter</a> is specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-13">operation</a> with an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-26">identifier</a>,
then indexing an object with an integer that is not a <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-2">supported property index</a> does not necessarily elicit the same behavior as invoking the operation with that index. The actual behavior in this
case is language binding specific.</p>
<p>In the ECMAScript language binding, a regular property lookup is done. For example, take the following IDL:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">getter</span> <span class="kt">DOMString</span> <span class="nv">toWord</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>);
};
</pre>
<p>Assume that an object implementing <code class="idl">A</code> has <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-3">supported property indices</a> in the range 0 ≤ <var>index</var> < 2. Also assume that toWord is defined to return
its argument converted into an English word. The behavior when invoking the <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-14">operation</a> with an out of range index
is different from indexing the object directly:</p>
<pre class="highlight"><span class="kd">var</span> a <span class="o">=</span> getA<span class="p">(</span><span class="p">)</span><span class="p">;</span>
a<span class="p">.</span>toWord<span class="p">(</span><span class="mi">0</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evalautes to "zero".
</span>a<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">;</span> <span class="c1">// Also evaluates to "zero".
</span>
a<span class="p">.</span>toWord<span class="p">(</span><span class="mi">5</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to "five".
</span>a<span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="p">;</span> <span class="c1">// Evaluates to undefined, since there is no property "5".
</span></pre>
</div>
<div class="example" id="example-120b3f16">
<a class="self-link" href="#example-120b3f16"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-22">IDL fragment</a> defines an interface <code class="idl">OrderedMap</code> which allows
retrieving and setting values by name or by index number:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">OrderedMap</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">size</span>;
<span class="kt">getter</span> <span class="kt">any</span> <span class="nv">getByIndex</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>);
<span class="kt">setter</span> <span class="kt">void</span> <span class="nv">setByIndex</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>, <span class="kt">any</span> <span class="nv">value</span>);
<span class="kt">getter</span> <span class="kt">any</span> <span class="nv">get</span>(<span class="kt">DOMString</span> <span class="nv">name</span>);
<span class="kt">setter</span> <span class="kt">void</span> <span class="nv">set</span>(<span class="kt">DOMString</span> <span class="nv">name</span>, <span class="kt">any</span> <span class="nv">value</span>);
};
</pre>
<p>Since all of the special operations are declared using
operations with identifiers, the only additional prose
that is necessary is that which describes what keys those sets
have. Assuming that the <code>get()</code> operation is
defined to return <emu-val>null</emu-val> if an
attempt is made to look up a non-existing entry in the <code class="idl">OrderedMap</code>, then the following
two sentences would suffice:</p>
<blockquote>
<p>An object <var>map</var> implementing <code class="idl">OrderedMap</code> supports indexed properties with indices in the range
0 ≤ <var>index</var> < <code>map.size</code>.</p>
<p>Such objects also support a named property for every name that,
if passed to <code>get()</code>, would return a non-null value.</p>
</blockquote>
<p>As described in <a href="#es-platform-objects">§3.8 Platform objects implementing interfaces</a>,
an ECMAScript implementation would create
properties on a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-3">platform object</a> implementing <code class="idl">OrderedMap</code> that correspond to
entries in both the named and indexed property sets.
These properties can then be used to interact
with the object in the same way as invoking the object’s
methods, as demonstrated below:</p>
<pre class="highlight"><span class="c1">// Assume map is a platform object implementing the OrderedMap interface.
</span><span class="kd">var</span> map <span class="o">=</span> getOrderedMap<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="kd">var</span> x<span class="p">,</span> y<span class="p">;</span>
x <span class="o">=</span> map<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">;</span> <span class="c1">// If map.length > 0, then this is equivalent to:
</span> <span class="c1">//
</span> <span class="c1">// x = map.getByIndex(0)
</span> <span class="c1">//
</span> <span class="c1">// since a property named "0" will have been placed on map.
</span> <span class="c1">// Otherwise, x will be set to undefined, since there will be
</span> <span class="c1">// no property named "0" on map.
</span>
map<span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="kc">false</span><span class="p">;</span> <span class="c1">// This will do the equivalent of:
</span> <span class="c1">//
</span> <span class="c1">// map.setByIndex(1, false)
</span>
y <span class="o">=</span> map<span class="p">.</span>apple<span class="p">;</span> <span class="c1">// If there exists a named property named "apple", then this
</span> <span class="c1">// will be equivalent to:
</span> <span class="c1">//
</span> <span class="c1">// y = map.get('apple')
</span> <span class="c1">//
</span> <span class="c1">// since a property named "apple" will have been placed on
</span> <span class="c1">// map. Otherwise, y will be set to undefined, since there
</span> <span class="c1">// will be no property named "apple" on map.
</span>
map<span class="p">.</span>berry <span class="o">=</span> <span class="mi">123</span><span class="p">;</span> <span class="c1">// This will do the equivalent of:
</span> <span class="c1">//
</span> <span class="c1">// map.set('berry', 123)
</span>
<span class="k">delete</span> map<span class="p">.</span>cake<span class="p">;</span> <span class="c1">// If a named property named "cake" exists, then the "cake"
</span> <span class="c1">// property will be deleted, and then the equivalent to the
</span> <span class="c1">// following will be performed:
</span> <span class="c1">//
</span> <span class="c1">// map.remove("cake")
</span></pre>
</div>
<h5 class="heading settled dfn-paneled" data-dfn-type="dfn" data-export="" data-level="2.2.4.5" data-lt="Named properties" id="idl-named-properties"><span class="secno">2.2.4.5. </span><span class="content">Named properties</span></h5>
<p>An <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-33">interface</a> that defines
a <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-2">named property getter</a> is said to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-support-named-properties">support named properties</dfn>.</p>
<p>If an interface <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-1">supports named properties</a>,
then the interface definition must be accompanied by
a description of the ordered set of names that can be used to index the object
at any given time. These names are called the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-supported-property-names">supported property names</dfn>.</p>
<p>Named property getters and deleters must
be declared to take a single <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-12">DOMString</a></code> argument.
Named property setters must
be declared to take two arguments, where the first is a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-13">DOMString</a></code>.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">getter</span> <span class="n">type</span> <span class="nv">identifier</span>(<span class="kt">DOMString</span> <span class="nv">identifier</span>);
<span class="kt">setter</span> <span class="n">type</span> <span class="nv">identifier</span>(<span class="kt">DOMString</span> <span class="nv">identifier</span>, <span class="n">type</span> <span class="nv">identifier</span>);
<span class="kt">deleter</span> <span class="n">type</span> <span class="nv">identifier</span>(<span class="kt">DOMString</span> <span class="nv">identifier</span>);
<span class="kt">getter</span> <span class="n">type</span> (<span class="kt">DOMString</span> <span class="nv">identifier</span>);
<span class="kt">setter</span> <span class="n">type</span> (<span class="kt">DOMString</span> <span class="nv">identifier</span>, <span class="n">type</span> <span class="nv">identifier</span>);
<span class="kt">deleter</span> <span class="n">type</span> (<span class="kt">DOMString</span> <span class="nv">identifier</span>);
};
</pre>
<p>The following requirements apply to the definitions of named property getters, setters and deleters:</p>
<ul>
<li data-md="">
<p>If a <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-3">named property getter</a> was specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-15">operation</a> with an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-27">identifier</a>,
then the value returned when indexing the object with a given <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-1">supported property name</a> is the value that would be returned by invoking the operation, passing
the name as its only argument. If the operation used to declare the named property getter
did not have an identifier, then the interface definition must be accompanied
by a description of how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-determine-the-value-of-a-named-property">determine the value of a named property</dfn> for a given property name.</p>
<li data-md="">
<p>If a <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-1">named property setter</a> was specified using an operation
with an identifier,
then the behavior that occurs when indexing the object for property assignment with a given supported property name and value
is the same as if the operation is invoked, passing
the name as the first argument and the value as the second argument. If the operation used to declare the named property setter
did not have an identifier, then the interface definition must be accompanied
by a description of how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-set-the-value-of-an-existing-named-property">set the value of an existing named property</dfn> and how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-set-the-value-of-a-new-named-property">set the value of a new named property</dfn> for a given property name and value.</p>
<li data-md="">
<p>If a <a data-link-type="dfn" href="#dfn-named-property-deleter" id="ref-for-dfn-named-property-deleter-3">named property deleter</a> was specified using an operation
with an identifier,
then the behavior that occurs when indexing the object for property deletion with a given supported property name
is the same as if the operation is invoked, passing
the name as the only argument. If the operation used to declare the named property deleter
did not have an identifier, then the interface definition must be accompanied
by a description of how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-delete-an-existing-named-property">delete an existing named property</dfn> for a given property name.</p>
</ul>
<p class="note" role="note">Note: As with <a data-link-type="dfn" href="#idl-indexed-properties" id="ref-for-idl-indexed-properties-2">indexed properties</a>,
if an <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-4">named property getter</a>, <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-2">setter</a> or <a data-link-type="dfn" href="#dfn-named-property-deleter" id="ref-for-dfn-named-property-deleter-4">deleter</a> is specified using an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-16">operation</a> with an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-28">identifier</a>,
then indexing an object with a name that is not a <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-2">supported property name</a> does not necessarily elicit the same behavior as invoking the operation with that name; the behavior
is language binding specific.</p>
<h4 class="heading settled" data-level="2.2.5" id="idl-static-attributes-and-operations"><span class="secno">2.2.5. </span><span class="content">Static attributes and operations</span><a class="self-link" href="#idl-static-attributes-and-operations"></a></h4>
<p><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-static-attribute">Static attributes</dfn> and <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-static-operation">static operations</dfn> are ones that
are not associated with a particular instance of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-34">interface</a> on which it is declared, and is instead associated with the interface
itself. Static attributes and operations are declared by using the <code>static</code> keyword in their declarations.</p>
<p>It is language binding specific whether it is possible to invoke
a static operation or get or set a static attribute through a reference
to an instance of the interface.</p>
<p>Static attributes and operations must not be
declared on <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-8">callback interfaces</a>.</p>
<pre class="grammar" id="prod-StaticMember">StaticMember :
"static" StaticMemberRest
</pre>
<pre class="grammar" id="prod-StaticMemberRest">StaticMemberRest :
ReadOnly AttributeRest
ReturnType OperationRest
</pre>
<div class="example" id="example-782f62c1">
<a class="self-link" href="#example-782f62c1"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-23">IDL fragment</a> defines an interface <code class="idl">Circle</code> that has a static
operation declared on it:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Point</span> { /* ... */ };
<span class="kt">interface</span> <span class="nv">Circle</span> {
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">cx</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">cy</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">radius</span>;
<span class="kt">static</span> <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">triangulationCount</span>;
<span class="kt">static</span> <span class="n">Point</span> <span class="nv">triangulate</span>(<span class="n">Circle</span> <span class="nv">c1</span>, <span class="n">Circle</span> <span class="nv">c2</span>, <span class="n">Circle</span> <span class="nv">c3</span>);
};
</pre>
<p>In the ECMAScript language binding, the <emu-val>Function</emu-val> object for <code>triangulate</code> and the accessor property for <code>triangulationCount</code> will exist on the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-1">interface object</a> for <code class="idl">Circle</code>:</p>
<pre class="highlight"><span class="kd">var</span> circles <span class="o">=</span> getCircles<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// an Array of Circle objects
</span>
<span class="k">typeof</span> Circle<span class="p">.</span>triangulate<span class="p">;</span> <span class="c1">// Evaluates to "function"
</span><span class="k">typeof</span> Circle<span class="p">.</span>triangulationCount<span class="p">;</span> <span class="c1">// Evaluates to "number"
</span>Circle<span class="p">.</span>prototype<span class="p">.</span>triangulate<span class="p">;</span> <span class="c1">// Evaluates to undefined
</span>Circle<span class="p">.</span>prototype<span class="p">.</span>triangulationCount<span class="p">;</span> <span class="c1">// Also evaluates to undefined
</span>circles<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">.</span>triangulate<span class="p">;</span> <span class="c1">// As does this
</span>circles<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">.</span>triangulationCount<span class="p">;</span> <span class="c1">// And this
</span>
<span class="c1">// Call the static operation
</span><span class="kd">var</span> triangulationPoint <span class="o">=</span> Circle<span class="p">.</span>triangulate<span class="p">(</span>circles<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">,</span> circles<span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="p">,</span> circles<span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Find out how many triangulations we have done
</span>window<span class="p">.</span>alert<span class="p">(</span>Circle<span class="p">.</span>triangulationCount<span class="p">)</span><span class="p">;</span>
</pre>
</div>
<h4 class="heading settled" data-level="2.2.6" id="idl-overloading"><span class="secno">2.2.6. </span><span class="content">Overloading</span><a class="self-link" href="#idl-overloading"></a></h4>
<p>If a <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-5">regular operation</a> or <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-5">static operation</a> defined on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-35">interface</a> has an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-29">identifier</a> that is the same as the identifier of another operation on that
interface of the same kind (regular or static), then the operation is said to be <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-overloaded">overloaded</dfn>. When the identifier
of an overloaded operation is used to invoke one of the
operations on an object that implements the interface, the
number and types of the arguments passed to the operation
determine which of the overloaded operations is actually
invoked. If an interface has multiple <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-3">legacy callers</a> defined on it,
then those legacy callers are also said to be overloaded.
In the ECMAScript language binding, <a href="#Constructor" id="ref-for-Constructor-5">constructors</a> can be overloaded too. There are some restrictions on the arguments
that overloaded operations, legacy callers and constructors can be
specified to take, and in order to describe these restrictions,
the notion of an <em>effective overload set</em> is used.</p>
<p><a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-17">Operations</a> and <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-4">legacy callers</a> must not be overloaded across <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-36">interface</a> and <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-6">partial interface</a> definitions.</p>
<div class="note" role="note">
<p>For example, the overloads for both <var>f</var> and <var>g</var> are disallowed:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">f</span>();
};
<span class="kt">partial</span> <span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">f</span>(<span class="kt">double</span> <span class="nv">x</span>);
<span class="kt">void</span> <span class="nv">g</span>();
};
<span class="kt">partial</span> <span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">g</span>(<span class="kt">DOMString</span> <span class="nv">x</span>);
};
</pre>
<p>Note that the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-6">Constructor</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-4">NamedConstructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-11">extended attributes</a> are disallowed from appearing
on <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-7">partial interface</a> definitions,
so there is no need to also disallow overloading for constructors.</p>
</div>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-effective-overload-set">effective overload set</dfn> represents the allowable invocations for a particular <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-18">operation</a>,
constructor (specified with [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-7">Constructor</a></code>]
or [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-5">NamedConstructor</a></code>]), <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-5">legacy caller</a> or <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-11">callback function</a>.
The algorithm to compute an <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-1">effective overload set</a> operates on one of the following six types of IDL constructs, and listed with them below are
the inputs to the algorithm needed to compute the set.</p>
<dl>
<dt data-md="">
<p>For regular operations</p>
<dt data-md="">
<p>For static operations</p>
<dd data-md="">
<ul>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-37">interface</a> on which the <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-19">operations</a> are to be found</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-30">identifier</a> of the operations</p>
<li data-md="">
<p>the number of arguments to be passed</p>
</ul>
<dt data-md="">
<p>For legacy callers</p>
<dd data-md="">
<ul>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-38">interface</a> on which the <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-6">legacy callers</a> are to be found</p>
<li data-md="">
<p>the number of arguments to be passed</p>
</ul>
<dt data-md="">
<p>For constructors</p>
<dd data-md="">
<ul>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-39">interface</a> on which the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-8">Constructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-12">extended attributes</a> are to be found</p>
<li data-md="">
<p>the number of arguments to be passed</p>
</ul>
<dt data-md="">
<p>For named constructors</p>
<dd data-md="">
<ul>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-40">interface</a> on which the [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-6">NamedConstructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-13">extended attributes</a> are to be found</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-31">identifier</a> of the named constructors</p>
<li data-md="">
<p>the number of arguments to be passed</p>
</ul>
<dt data-md="">
<p>For callback functions</p>
<dd data-md="">
<ul>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-12">callback function</a></p>
<li data-md="">
<p>the number of arguments to be passed</p>
</ul>
</dl>
<p>An effective overload set is used, among other things, to determine whether there are ambiguities in the
overloaded operations, constructors and callers specified on an interface.</p>
<p>The elements of an effective overload set are tuples of the form
<<var>callable</var>, <var>type list</var>, <var>optionality list</var>>. If the effective overload
set is for regular operations, static operations or legacy callers, then <var>callable</var> is an operation;
if it is for constructors or named constructors, then <var>callable</var> is an
extended attribute; and if it is for callback functions, then <var>callable</var> is the callback function itself. In all cases, <var>type list</var> is a list
of IDL types, and <var>optionality list</var> is a list of three possible <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-optionality-value">optionality values</dfn> –
“required”, “optional” or “variadic” – indicating whether
the argument at a given index was declared as being <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-4">optional</a> or corresponds to a <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-6">variadic</a> argument.
Each tuple represents an allowable invocation of the operation,
constructor, legacy caller or callback function with an argument value list of the given types.
Due to the use of <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-5">optional arguments</a> and <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-7">variadic</a> operations
and constructors, there may be multiple entries in an effective overload set identifying
the same operation or constructor.</p>
<p>The algorithm below describes how to compute an effective overload set.
The following input variables are used, if they are required:</p>
<ul>
<li data-md="">
<p>the identifier of the operation or named constructor is <var>A</var></p>
<li data-md="">
<p>the argument count is <var>N</var></p>
<li data-md="">
<p>the interface is <var>I</var></p>
<li data-md="">
<p>the callback function is <var>C</var></p>
</ul>
<p>Whenever an argument of an extended
attribute is mentioned, it is referring to an argument of the
extended attribute’s <a data-link-type="dfn" href="#dfn-xattr-named-argument-list" id="ref-for-dfn-xattr-named-argument-list-1">named argument list</a>.</p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>S</var> to ∅.</p>
<li data-md="">
<p>Let <var>F</var> be a set with elements as follows, according to the kind of effective overload set:</p>
<dl class="switch">
<dt data-md="">
<p>For regular operations</p>
<dd data-md="">
<p>The elements of <var>F</var> are the <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-6">regular operations</a> with
identifier <var>A</var> defined on interface <var>I</var>.</p>
<dt data-md="">
<p>For static operations</p>
<dd data-md="">
<p>The elements of <var>F</var> are the <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-6">static operations</a> with
identifier <var>A</var> defined on interface <var>I</var>.</p>
<dt data-md="">
<p>For constructors</p>
<dd data-md="">
<p>The elements of <var>F</var> are the
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-9">Constructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-14">extended attributes</a> on interface <var>I</var>.</p>
<dt data-md="">
<p>For named constructors</p>
<dd data-md="">
<p>The elements of <var>F</var> are the
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-7">NamedConstructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-15">extended attributes</a> on interface <var>I</var> whose <a data-link-type="dfn" href="#dfn-xattr-named-argument-list" id="ref-for-dfn-xattr-named-argument-list-2">named argument lists’</a> identifiers are <var>A</var>.</p>
<dt data-md="">
<p>For legacy callers</p>
<dd data-md="">
<p>The elements of <var>F</var> are the <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-7">legacy callers</a> defined on interface <var>I</var>.</p>
<dt data-md="">
<p>For callback functions</p>
<dd data-md="">
<p>The single element of <var>F</var> is the callback function itself, <var>C</var>.</p>
</dl>
<li data-md="">
<p>Let <var>maxarg</var> be the maximum number of arguments the operations, constructor extended attributes or callback functions in <var>F</var> are declared to take.
For <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-8">variadic</a> operations and constructor extended attributes,
the argument on which the ellipsis appears counts as a single argument.</p>
<p class="note" role="note">Note: So <code>void f(long x, long... y);</code> is considered to be declared to take two arguments.</p>
<li data-md="">
<p>Let <var>m</var> be the maximum of <var>maxarg</var> and <var>N</var>.</p>
<li data-md="">
<p>For each operation, extended attribute or callback function <var>X</var> in <var>F</var>:</p>
<ol>
<li data-md="">
<p>Let <var>n</var> be the number of arguments <var>X</var> is declared to take.</p>
<li data-md="">
<p>Let <var>t</var><sub>0..<var>n</var>−1</sub> be a list of types, where <var>t</var><sub><var>i</var></sub> is the type of <var>X</var>’s argument at index <var>i</var>.</p>
<li data-md="">
<p>Let <var>o</var><sub>0..<var>n</var>−1</sub> be a list of <a data-link-type="dfn" href="#dfn-optionality-value" id="ref-for-dfn-optionality-value-1">optionality values</a>, where <var>o</var><sub><var>i</var></sub> is “variadic” if <var>X</var>’s argument at index <var>i</var> is a final, variadic argument,
“optional” if the argument is <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-6">optional</a>,
and “required” otherwise.</p>
<li data-md="">
<p>Add to <var>S</var> the tuple <<var>X</var>, <var>t</var><sub>0..<var>n</var>−1</sub>, <var>o</var><sub>0..<var>n</var>−1</sub>>.</p>
<li data-md="">
<p>If <var>X</var> is declared to be <a data-link-type="dfn" href="#dfn-variadic" id="ref-for-dfn-variadic-9">variadic</a>, then:</p>
<ol>
<li data-md="">
<p>For every integer <var>i</var>, such that <var>n</var> ≤ <var>i</var> ≤ <var>m</var>−1:</p>
<ol>
<li data-md="">
<p>Let <var>u</var><sub>0..<var>i</var></sub> be a list of types, where <var>u</var><sub>j</sub> = <var>t</var><sub>j</sub> (for <var>j</var> < <var>n</var>) and <var>u</var><sub>j</sub> = <var>t</var><sub><var>n</var>−1</sub> (for <var>j</var> ≥ <var>n</var>).</p>
<li data-md="">
<p>Let <var>p</var><sub>0..<var>i</var></sub> be a list of <a data-link-type="dfn" href="#dfn-optionality-value" id="ref-for-dfn-optionality-value-2">optionality values</a>, where <var>p</var><sub>j</sub> = <var>o</var><sub>j</sub> (for <var>j</var> < <var>n</var>) and <var>p</var><sub>j</sub> = “variadic” (for <var>j</var> ≥ <var>n</var>).</p>
<li data-md="">
<p>Add to <var>S</var> the tuple <<var>X</var>, <var>u</var><sub>0..<var>i</var></sub>, <var>p</var><sub>0..<var>i</var></sub>>.</p>
</ol>
</ol>
<li data-md="">
<p>Initialize <var>i</var> to <var>n</var>−1.</p>
<li data-md="">
<p>While <var>i</var> ≥ 0:</p>
<ol>
<li data-md="">
<p>If argument <var>i</var> of <var>X</var> is not <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-7">optional</a> (i.e., it is not marked as <code>optional</code> and is not
a final, variadic argument), then break this loop.</p>
<li data-md="">
<p>Otherwise, add to <var>S</var> the tuple <<var>X</var>, <var>t</var><sub>0..<var>i</var>−1</sub>, <var>o</var><sub>0..<var>i</var>−1</sub>>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var>−1.</p>
</ol>
</ol>
<li data-md="">
<p>The effective overload set is <var>S</var>.</p>
</ol>
<div class="example" id="example-86a20b01">
<a class="self-link" href="#example-86a20b01"></a>
<p>For the following interface:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
/* f1 */ <span class="kt">void</span> <span class="nv">f</span>(<span class="kt">DOMString</span> <span class="nv">a</span>);
/* f2 */ <span class="kt">void</span> <span class="nv">f</span>(<span class="n">Node</span> <span class="nv">a</span>, <span class="kt">DOMString</span> <span class="nv">b</span>, <span class="kt">double</span>... <span class="nv">c</span>);
/* f3 */ <span class="kt">void</span> <span class="nv">f</span>();
/* f4 */ <span class="kt">void</span> <span class="nv">f</span>(<span class="n">Event</span> <span class="nv">a</span>, <span class="kt">DOMString</span> <span class="nv">b</span>, <span class="kt">optional</span> <span class="kt">DOMString</span> <span class="nv">c</span>, <span class="kt">double</span>... <span class="nv">d</span>);
};
</pre>
<p>assuming <code class="idl">Node</code> and <code class="idl">Event</code> are two other interfaces of which no object can implement both,
the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-2">effective overload set</a> for <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-7">regular operations</a> with
identifier <code>f</code> and argument count 4 is:</p>
<pre class="set">{ <f1, (DOMString), (required)>,
<f2, (Node, DOMString), (required, required)>,
<f2, (Node, DOMString, double), (required, required, variadic)>,
<f2, (Node, DOMString, double, double), (required, required, variadic, variadic)>,
<f3, (), ()>,
<f4, (Event, DOMString), (required, required)>,
<f4, (Event, DOMString, DOMString), (required, required, optional)>,
<f4, (Event, DOMString, DOMString, double), (required, required, optional, variadic)> }
</pre>
</div>
<p>Two types are <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-distinguishable">distinguishable</dfn> if
at most one of the two <a data-link-type="dfn" href="#dfn-includes-a-nullable-type" id="ref-for-dfn-includes-a-nullable-type-1">includes a nullable type</a> or is a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-3">dictionary type</a>,
and at least one of the following three conditions is true:</p>
<ol>
<li data-md="">
<p>The two types (taking their <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-3">inner types</a> if they are <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-7">nullable types</a>) appear
in the following table and there is a “●” mark in the corresponding entry
or there is a letter in the corresponding entry and the designated additional
requirement below the table is satisfied:</p>
<table class="matrix data complex" id="distinguishable-table">
<tbody>
<tr>
<th class="corner">
<th>
<div> <span>boolean</span> </div>
<th>
<div> <span>numeric types</span> </div>
<th>
<div> <span>string types</span> </div>
<th>
<div> <span>interface</span> </div>
<th>
<div> <span>object</span> </div>
<th>
<div> <span>callback function</span> </div>
<th>
<div> <span>dictionary</span> </div>
<th>
<div> <span>sequence<<var>T</var>></span> </div>
<th>
<div> <span>FrozenArray<<var>T</var>></span> </div>
<th>
<div> <span>RegExp</span> </div>
<th>
<div> <span>exception types</span> </div>
<th>
<div> <span>buffer source types</span> </div>
<tr>
<th>boolean
<td>
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<tr>
<th>numeric types
<td class="belowdiagonal">
<td>
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<tr>
<th>string types
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<td>●
<tr>
<th>interface
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>(a)
<td>
<td>(b)
<td>(b)
<td>●
<td>●
<td>●
<td>●
<td>●
<tr>
<th>object
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>
<td>
<td>
<td>
<td>
<td>
<td>
<tr>
<th>callback function
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>
<td>●
<td>●
<td>●
<td>●
<td>●
<tr>
<th>dictionary
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>●
<td>●
<td>●
<td>●
<td>●
<tr>
<th>sequence<<var>T</var>>
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>
<td>●
<td>●
<td>●
<tr>
<th>FrozenArray<<var>T</var>>
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>●
<td>●
<td>●
<tr>
<th>RegExp
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>●
<td>●
<tr>
<th>exception types
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
<td>●
<tr>
<th>buffer source types
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td class="belowdiagonal">
<td>
</table>
<ol type="a">
<li data-md="">
<p>The two identified <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-41">interfaces</a> are
not the same, it is not possible for a single <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-4">platform object</a> to implement both <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-42">interfaces</a>,
and it is not the case that both are <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-9">callback interfaces</a>.</p>
<li data-md="">
<p>The interface type is not a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-10">callback interface</a>.</p>
</ol>
<li data-md="">
<p>One type is a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-5">union type</a> or nullable union type,
the other is neither a union type nor a nullable union type, and each <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-2">member type</a> of the first is distinguishable
with the second.</p>
<li data-md="">
<p>Both types are either a union type or nullable union type, and each member type of the one
is distinguishable with each member type of the other.</p>
</ol>
<p class="note" role="note">Note: <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-2">Promise types</a> do not appear in the above table, and as a consequence
are not distinguishable with any other type.</p>
<p>If there is more than one entry in an <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-3">effective overload set</a> that has a given type list length, then for those entries there
must be an index <var>i</var> such
that for each pair of entries the types at index <var>i</var> are <a data-link-type="dfn" href="#dfn-distinguishable" id="ref-for-dfn-distinguishable-1">distinguishable</a>.
The lowest such index is termed the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-distinguishing-argument-index">distinguishing argument index</dfn> for the entries of the effective overload set with the given type list length.</p>
<div class="example" id="example-f77d04f0">
<a class="self-link" href="#example-f77d04f0"></a>
<p>Consider the effective overload set shown in the previous example.
There are multiple entries in the set with type lists 2, 3 and 4.
For each of these type list lengths, the <a data-link-type="dfn" href="#dfn-distinguishing-argument-index" id="ref-for-dfn-distinguishing-argument-index-1">distinguishing argument index</a> is 0, since <code class="idl">Node</code> and <code class="idl">Event</code> are <a data-link-type="dfn" href="#dfn-distinguishable" id="ref-for-dfn-distinguishable-2">distinguishable</a>.</p>
<p>The following use of overloading however is invalid:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">B</span> {
<span class="kt">void</span> <span class="nv">f</span>(<span class="kt">DOMString</span> <span class="nv">x</span>);
<span class="kt">void</span> <span class="nv">f</span>(<span class="kt">double</span> <span class="nv">x</span>);
};
</pre>
<p>since <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-14">DOMString</a></code> and <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-7">double</a></code> are not distinguishable.</p>
</div>
<p>In addition, for each index <var>j</var>, where <var>j</var> is less than the <a data-link-type="dfn" href="#dfn-distinguishing-argument-index" id="ref-for-dfn-distinguishing-argument-index-2">distinguishing argument index</a> for a given type list length, the types at index <var>j</var> in
all of the entries’ type lists must be the same
and the booleans in the corresponding list indicating argument optionality must
be the same.</p>
<div class="example" id="example-11d7a305">
<a class="self-link" href="#example-11d7a305"></a>
<p>The following is invalid:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">B</span> {
/* f1 */ <span class="kt">void</span> <span class="nv">f</span>(<span class="kt">DOMString</span> <span class="nv">w</span>);
/* f2 */ <span class="kt">void</span> <span class="nv">f</span>(<span class="kt">long</span> <span class="nv">w</span>, <span class="kt">double</span> <span class="nv">x</span>, <span class="n">Node</span> <span class="nv">y</span>, <span class="n">Node</span> <span class="nv">z</span>);
/* f3 */ <span class="kt">void</span> <span class="nv">f</span>(<span class="kt">double</span> <span class="nv">w</span>, <span class="kt">double</span> <span class="nv">x</span>, <span class="kt">DOMString</span> <span class="nv">y</span>, <span class="n">Node</span> <span class="nv">z</span>);
};
</pre>
<p>For argument count 4, the effective overload set is:</p>
<pre class="set">{ <f1, (DOMString), (required)>,
<f2, (long, double, Node, Node), (required, required, required, required)>,
<f3, (double, double, DOMString, Node), (required, required, required, required)> }
</pre>
<p>Looking at entries with type list length 4, the <a data-link-type="dfn" href="#dfn-distinguishing-argument-index" id="ref-for-dfn-distinguishing-argument-index-3">distinguishing argument index</a> is 2, since <code class="idl">Node</code> and <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-15">DOMString</a></code> are <a data-link-type="dfn" href="#dfn-distinguishable" id="ref-for-dfn-distinguishable-3">distinguishable</a>.
However, since the arguments in these two overloads at index 0 are different,
the overloading is invalid.</p>
</div>
<h4 class="heading settled" data-level="2.2.7" id="idl-iterable"><span class="secno">2.2.7. </span><span class="content">Iterable declarations</span><a class="self-link" href="#idl-iterable"></a></h4>
<p>An <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-43">interface</a> can be declared to be <dfn data-dfn-type="dfn" data-export="" id="dfn-iterable">iterable<a class="self-link" href="#dfn-iterable"></a></dfn> by using an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-iterable-declaration">iterable declaration</dfn> (matching <emu-nt><a href="#prod-Iterable">Iterable</a></emu-nt>) in the body of the interface.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">iterable</span><<span class="n">value_type</span>>;
<span class="kt">iterable</span><<span class="n">key_type</span>, <span class="n">value_type</span>>;
};
</pre>
<p>Objects implementing an interface that is declared to be iterable
support being iterated over to obtain a sequence of values.</p>
<p class="note" role="note">Note: In the ECMAScript language binding, an interface that is iterable
will have “entries”, “forEach”, “keys”, “values” and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> properties on its <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-1">interface prototype object</a>.</p>
<p>If a single type parameter is given, then the interface has a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-value-iterator">value iterator</dfn> and provides
values of the specified type.
If two type parameters are given, then the interface has a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-pair-iterator">pair iterator</dfn> and provides
value pairs, where the first value is a key and the second is the
value associated with the key.</p>
<p>A <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-1">value iterator</a> must only be declared on an interface
that <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-2">supports indexed properties</a> and has an <a data-link-type="dfn" href="#dfn-integer-type" id="ref-for-dfn-integer-type-2">integer-typed</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-11">attribute</a> named “length”.
The value-type of the <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-2">value iterator</a> must be the same as the type returned by
the <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-4">indexed property getter</a>.
A <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-3">value iterator</a> is implicitly
defined to iterate over the object’s indexed properties.</p>
<p>A <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-1">pair iterator</a> must not be declared on an interface
that <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-3">supports indexed properties</a>.
Prose accompanying an interface with a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-2">pair iterator</a> must define what the list of <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-value-pairs-to-iterate-over">value pairs to iterate over</dfn> is.</p>
<div class="note" role="note">
<p>The ECMAScript forEach method that is generated for a <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-4">value iterator</a> invokes its callback like Array.prototype.forEach does, and the forEach
method for a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-3">pair iterator</a> invokes its callback like Map.prototype.forEach does.</p>
<p>Since <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-5">value iterators</a> are currently allowed only on interfaces that <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-4">support indexed properties</a>,
it makes sense to use an Array-like forEach method.
There may be a need for <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-6">value iterators</a> (a) on interfaces that do not <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-5">support indexed properties</a>,
or (b) with a forEach method that instead invokes its callback like
Set.protoype.forEach (where the key is the same as the value).
If you’re creating an API that needs such a forEach method, please send a request to <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a>.</p>
</div>
<p class="note" role="note">Note: This is how <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-array-iterator-objects">array iterator objects</a> work.
For interfaces that <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-6">support indexed properties</a>,
the iterator objects returned by “entries”, “keys”, “values” and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> are
actual <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-array-iterator-objects">array iterator objects</a>.</p>
<p>Interfaces with iterable declarations must not
have any <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-7">interface members</a> named “entries”, “forEach”, “keys” or “values”,
or have any <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-3">inherited</a> or <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-2">consequential</a> interfaces that have interface members with these names.</p>
<div class="example" id="example-3cfb2da1">
<a class="self-link" href="#example-3cfb2da1"></a>
<p>Consider the following interface <code class="idl">SessionManager</code>, which allows access to
a number of <code class="idl">Session</code> objects:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">SessionManager</span> {
<span class="n">Session</span> <span class="nv">getSessionForUser</span>(<span class="kt">DOMString</span> <span class="nv">username</span>);
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">sessionCount</span>;
<span class="kt">iterable</span><<span class="n">Session</span>>;
};
<span class="kt">interface</span> <span class="nv">Session</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">username</span>;
// ...
};
</pre>
<p>The behavior of the iterator could be defined like so:</p>
<blockquote>
<p>The <a class="dfnref" href="#">values to iterate over</a> are the open <code class="idl">Session</code> objects
on the <code class="idl">SessionManager</code> sorted by username.</p>
<p class="issue" id="issue-d0d15dea"><a class="self-link" href="#issue-d0d15dea"></a> Fix reference to removed definition for "values to iterate over". </p>
</blockquote>
<p>In the ECMAScript language binding, the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-2">interface prototype object</a> for the <code class="idl">SessionManager</code> <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-44">interface</a> has a <code>values</code> method that is a function, which, when invoked,
returns an iterator object that itself has a <code>next</code> method that returns the
next value to be iterated over. It has <code>values</code> and <code>entries</code> methods that iterate over the indexes of the list of session objects
and [index, session object] pairs, respectively. It also has
a <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> method that allows a <code class="idl">SessionManager</code> to be used in a <code>for..of</code> loop:</p>
<pre class="highlight"><span class="c1">// Get an instance of SessionManager.
</span><span class="c1">// Assume that it has sessions for two users, "anna" and "brian".
</span><span class="kd">var</span> sm <span class="o">=</span> getSessionManager<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="k">typeof</span> SessionManager<span class="p">.</span>prototype<span class="p">.</span>values<span class="p">;</span> <span class="c1">// Evaluates to "function"
</span><span class="kd">var</span> it <span class="o">=</span> sm<span class="p">.</span>values<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// values() returns an iterator object
</span>String<span class="p">(</span>it<span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to "[object SessionManager Iterator]"
</span><span class="k">typeof</span> it<span class="p">.</span>next<span class="p">;</span> <span class="c1">// Evaluates to "function"
</span>
<span class="c1">// This loop will alert "anna" and then "brian".
</span><span class="k">for</span> <span class="p">(</span><span class="p">;</span><span class="p">;</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">let</span> result <span class="o">=</span> it<span class="p">.</span>next<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span>result<span class="p">.</span>done<span class="p">)</span> <span class="p">{</span>
<span class="k">break</span><span class="p">;</span>
<span class="p">}</span>
<span class="kd">let</span> session <span class="o">=</span> result<span class="p">.</span>value<span class="p">;</span>
window<span class="p">.</span>alert<span class="p">(</span>session<span class="p">.</span>username<span class="p">)</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">// This loop will also alert "anna" and then "brian".
</span><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> session <span class="k">of</span> sm<span class="p">)</span> <span class="p">{</span>
window<span class="p">.</span>alert<span class="p">(</span>session<span class="p">.</span>username<span class="p">)</span><span class="p">;</span>
<span class="p">}</span>
</pre>
</div>
<p>An interface must not have more than one <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-1">iterable declaration</a>.
The <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-4">inherited</a> and <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-3">consequential</a> interfaces of an interface with an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-2">iterable declaration</a> must not also have an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-3">iterable declaration</a>.
An interface with an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-4">iterable declaration</a> and its <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-5">inherited</a> and <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-4">consequential</a> interfaces must not have a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-1">maplike declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-1">setlike declaration</a>.</p>
<p>The following extended attributes are applicable to <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-5">iterable declarations</a>:
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-6">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-6">SecureContext</a></code>].</p>
<pre class="grammar" id="prod-Iterable">Iterable :
"iterable" "<" Type OptionalType ">" ";"
</pre>
<pre class="grammar" id="prod-OptionalType">OptionalType :
"," Type
ε
</pre>
<h4 class="heading settled" data-level="2.2.8" id="idl-maplike"><span class="secno">2.2.8. </span><span class="content">Maplike declarations</span><a class="self-link" href="#idl-maplike"></a></h4>
<p>An <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-45">interface</a> can be declared to be <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-maplike">maplike</dfn> by using a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-maplike-declaration">maplike declaration</dfn> (matching <emu-nt><a href="#prod-ReadWriteMaplike">ReadWriteMaplike</a></emu-nt> or <emu-t>readonly</emu-t> <emu-nt><a href="#prod-MaplikeRest">MaplikeRest</a></emu-nt>) in the body of the interface.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">readonly</span> <span class="kt">maplike</span><<span class="n">key_type</span>, <span class="n">value_type</span>>;
<span class="kt">maplike</span><<span class="n">key_type</span>, <span class="n">value_type</span>>;
};
</pre>
<p>Objects implementing an interface that is declared to be maplike
represent an ordered list of key–value pairs known as its <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-map-entries">map entries</dfn>.
The types used for the keys and values are given in the angle
brackets of the maplike declaration. Keys are required to be unique.</p>
<p>The <a data-link-type="dfn" href="#dfn-map-entries" id="ref-for-dfn-map-entries-1">map entries</a> of an object
implementing a <a data-link-type="dfn" href="#dfn-maplike" id="ref-for-dfn-maplike-1">maplike</a> interface is empty at
the of the object’s creation. Prose accompanying the interface can
describe how the <a data-link-type="dfn" href="#dfn-map-entries" id="ref-for-dfn-map-entries-2">map entries</a> of an object change.</p>
<p>Maplike interfaces support an API for querying the map entries
appropriate for the language binding. If the <code>readonly</code> keyword is not used, then it also supports an API for modifying
the map entries.</p>
<p class="note" role="note">Note: In the ECMAScript language binding, the API for interacting
with the map entries is similar to that available on ECMAScript <emu-val>Map</emu-val> objects. If the <code>readonly</code> keyword is used, this includes “entries”, “forEach”, “get”, “has”,
“keys”, “values”, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> methods and a “size” getter.
For read–write maplikes, it also includes “clear”, “delete” and
“set” methods.</p>
<p>Maplike interfaces must not
have any <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-8">interface members</a> named “entries”, “forEach”, “get”, “has”, “keys”, “size”, or “values”,
or have any <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-6">inherited</a> or <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-5">consequential</a> interfaces that have interface members with these names.
Read–write maplike interfaces must not
have any <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-12">attributes</a> or <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-13">constants</a> named
“clear”, “delete”, or “set”, or have any <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-7">inherited</a> or <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-6">consequential</a> interfaces that have attributes or constants with these names.</p>
<p class="note" role="note">Note: Operations named “clear”, “delete”, or “set” are allowed on read–write maplike
interfaces and will prevent the default implementation of these methods being
added to the interface prototype object in the ECMAScript language binding.
This allows the default behavior of these operations to be overridden.</p>
<p>An interface must not have more than one <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-2">maplike declaration</a>.
The <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-8">inherited</a> and <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-7">consequential</a> interfaces of a maplike interface must not
also have a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-3">maplike declaration</a>.
A maplike interface and its <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-9">inherited</a> and <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-8">consequential</a> interfaces must not have an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-6">iterable declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-2">setlike declaration</a>.</p>
<div data-fill-with="grammar-ReadOnlyMember"></div>
<div data-fill-with="grammar-ReadOnlyMemberRest"></div>
<pre class="grammar" id="prod-ReadWriteMaplike">ReadWriteMaplike :
MaplikeRest
</pre>
<pre class="grammar" id="prod-MaplikeRest">MaplikeRest :
"maplike" "<" Type "," Type ">" ";"
</pre>
<p>No <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-16">extended attributes</a> defined in this specification are applicable to <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-4">maplike declarations</a>.</p>
<p class="issue" id="issue-dbe4d1af"><a class="self-link" href="#issue-dbe4d1af"></a> Add example. </p>
<h4 class="heading settled" data-level="2.2.9" id="idl-setlike"><span class="secno">2.2.9. </span><span class="content">Setlike declarations</span><a class="self-link" href="#idl-setlike"></a></h4>
<p>An <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-46">interface</a> can be declared to be <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-setlike">setlike</dfn> by using a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-setlike-declaration">setlike declaration</dfn> (matching <emu-nt><a href="#prod-ReadWriteSetlike">ReadWriteSetlike</a></emu-nt> or <emu-t>readonly</emu-t> <emu-nt><a href="#prod-SetlikeRest">SetlikeRest</a></emu-nt>) in the body of the interface.</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">interface_identifier</span> {
<span class="kt">readonly</span> <span class="kt">setlike</span><<span class="n">type</span>>;
<span class="kt">setlike</span><<span class="n">type</span>>;
};
</pre>
<p>Objects implementing an interface that is declared to be setlike
represent an ordered list of values known as its <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-set-entries">set entries</dfn>.
The type of the values is given in the angle
brackets of the setlike declaration. Values are required to be unique.</p>
<p>The <a data-link-type="dfn" href="#dfn-set-entries" id="ref-for-dfn-set-entries-1">set entries</a> of an object
implementing a <a data-link-type="dfn" href="#dfn-setlike" id="ref-for-dfn-setlike-1">setlike</a> interface is empty at
the of the object’s creation. Prose accompanying the interface can
describe how the <a data-link-type="dfn" href="#dfn-set-entries" id="ref-for-dfn-set-entries-2">set entries</a> of an object change.</p>
<p>Setlike interfaces support an API for querying the set entries
appropriate for the language binding. If the <code>readonly</code> keyword is not used, then it also supports an API for modifying
the set entries.</p>
<p class="note" role="note">Note: In the ECMAScript language binding, the API for interacting
with the set entries is similar to that available on ECMAScript <emu-val>Set</emu-val> objects. If the <code>readonly</code> keyword is used, this includes “entries”, “forEach”, “has”,
“keys”, “values”, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> methods and a “size” getter.
For read–write setlikes, it also includes “add”, “clear”, and “delete” methods.</p>
<p>Setlike interfaces must not
have any <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-9">interface members</a> named “entries”, “forEach”, “has”, “keys”, “size”, or “values”,
or have any <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-10">inherited</a> or <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-9">consequential</a> interfaces that have interface members with these names..
Read–write setlike interfaces must not
have any <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-13">attributes</a> or <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-14">constants</a> named
“add”, “clear”, or “delete”, or have any <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-11">inherited</a> or <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-10">consequential</a> interfaces that have attributes or constants with these names.</p>
<p class="note" role="note">Note: Operations named “add”, “clear”, or “delete” are allowed on read–write setlike
interfaces and will prevent the default implementation of these methods being
added to the interface prototype object in the ECMAScript language binding.
This allows the default behavior of these operations to be overridden.</p>
<p>An interface must not have more than one <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-3">setlike declaration</a>.
The <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-12">inherited</a> and <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-11">consequential</a> interfaces of a setlike interface must not
also have a <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-4">setlike declaration</a>.
A setlike interface and its <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-13">inherited</a> and <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-12">consequential</a> interfaces must not have an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-7">iterable declaration</a> or <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-5">maplike declaration</a>.</p>
<div data-fill-with="grammar-ReadOnlyMember"></div>
<div data-fill-with="grammar-ReadOnlyMemberRest"></div>
<pre class="grammar" id="prod-ReadWriteSetlike">ReadWriteSetlike :
SetlikeRest
</pre>
<pre class="grammar" id="prod-SetlikeRest">SetlikeRest :
"setlike" "<" Type ">" ";"
</pre>
<p>No <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-17">extended attributes</a> defined in this specification are applicable to <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-5">setlike declarations</a>.</p>
<p class="issue" id="issue-dbe4d1af0"><a class="self-link" href="#issue-dbe4d1af0"></a> Add example. </p>
<h3 class="heading settled" data-level="2.3" id="idl-namespaces"><span class="secno">2.3. </span><span class="content">Namespaces</span><a class="self-link" href="#idl-namespaces"></a></h3>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-namespace">namespace</dfn> is a definition (matching <emu-nt><a href="#prod-Namespace">Namespace</a></emu-nt>) that declares a global singleton with
associated behaviors.</p>
<pre class="syntax highlight"><span class="kt">namespace</span> <span class="nv">identifier</span> {
/* namespace_members... */
};
</pre>
<p>A namespace is a specification of a set of <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="namespace member" id="dfn-namespace-member">namespace members</dfn> (matching <emu-nt><a href="#prod-NamespaceMembers">NamespaceMembers</a></emu-nt>), which are the <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-8">regular operations</a> that appear between the braces in
the namespace declaration. These operations describe the behaviors packaged into the
namespace.</p>
<p>As with interfaces, the IDL for namespaces can be split into multiple parts by using <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-partial-namespace">partial namespace</dfn> definitions
(matching <emu-t>partial</emu-t> <emu-nt><a href="#prod-Namespace">Namespace</a></emu-nt>). The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-32">identifier</a> of a partial namespace definition must be the same as the identifier of a namespace definition.
All of the members that appear on each of the partial namespace definitions are
considered to be members of the namespace itself.</p>
<pre class="syntax highlight"><span class="kt">namespace</span> <mark><span class="nv">SomeNamespace</span></mark> {
/* namespace_members... */
};
<span class="kt">partial</span> <span class="kt">namespace</span> <mark><span class="nv">SomeNamespace</span></mark> {
/* namespace_members... */
};
</pre>
<p class="note" role="note">Note: As with partial interface definitions, partial namespace definitions are intended for
use as a specification editorial aide, allowing the definition of a namespace to be
separated over more than one section of the document, and sometimes multiple
documents.</p>
<p>The order that members appear in has significance for property enumeration in the <a href="#es-namespaces">ECMAScript binding</a>.</p>
<p>Note that unlike interfaces or dictionaries, namespaces do not create types.</p>
<p>Of the extended attributes defined in this specification, only the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-7">Exposed</a></code>] and [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-7">SecureContext</a></code>] extended attributes are applicable to
namespaces.</p>
<div data-fill-with="grammar-Partial"></div>
<div data-fill-with="grammar-PartialDefinition"></div>
<pre class="grammar" id="prod-Namespace">Namespace :
"namespace" identifier "{" NamespaceMembers "}" ";"
</pre>
<pre class="grammar" id="prod-NamespaceMembers">NamespaceMembers :
ExtendedAttributeList NamespaceMember NamespaceMembers
ε
</pre>
<pre class="grammar" id="prod-NamespaceMember">NamespaceMember :
ReturnType OperationRest
</pre>
<div class="example" id="example-b5268d73">
<a class="self-link" href="#example-b5268d73"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-24">IDL fragment</a> defines an <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-5">namespace</a>.</p>
<pre class="highlight"><span class="kt">namespace</span> <span class="nv">VectorUtils</span> {
<span class="kt">double</span> <span class="nv">dotProduct</span>(<span class="n">Vector</span> <span class="nv">x</span>, <span class="n">Vector</span> <span class="nv">y</span>);
<span class="n">Vector</span> <span class="nv">crossProduct</span>(<span class="n">Vector</span> <span class="nv">x</span>, <span class="n">Vector</span> <span class="nv">y</span>);
};
</pre>
<p>An ECMAScript implementation would then expose a global property named <code>VectorUtils</code> which was a simple object (with prototype <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-object-prototype-object">%ObjectPrototype%</a>) with enumerable data properties for each declared operation:</p>
<pre class="highlight">Object<span class="p">.</span>getPrototypeOf<span class="p">(</span>VectorUtils<span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to Object.prototype.
</span>Object<span class="p">.</span>keys<span class="p">(</span>VectorUtils<span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to ["dotProduct", "crossProduct"].
</span>Object<span class="p">.</span>getOwnPropertyDescriptor<span class="p">(</span>VectorUtils<span class="p">,</span> <span class="s2">"dotProduct"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to { value: <a function>, enumerable: true, configurable: true, writable: true }.
</span></pre>
</div>
<h3 class="heading settled" data-level="2.4" id="idl-dictionaries"><span class="secno">2.4. </span><span class="content">Dictionaries</span><a class="self-link" href="#idl-dictionaries"></a></h3>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-dictionary">dictionary</dfn> is a definition (matching <emu-nt><a href="#prod-Dictionary">Dictionary</a></emu-nt>)
used to define an associative array data type with a fixed, ordered set of key–value pairs,
termed <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-dictionary-member">dictionary members</dfn>,
where keys are strings and values are of a particular type specified in the definition.</p>
<pre class="syntax highlight"><span class="kt">dictionary</span> <span class="nv">identifier</span> {
/* dictionary_members... */
};
</pre>
<p>Dictionaries are always passed by value. In language bindings where a dictionary is represented by an object of some kind, passing a
dictionary to a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-5">platform object</a> will not result in a reference to the dictionary being kept by that object.
Similarly, any dictionary returned from a platform object will be a copy and modifications made to it will not be visible to the platform object.</p>
<p>A dictionary can be defined to <dfn class="dfn-paneled" data-dfn-for="dictionary" data-dfn-type="dfn" data-export="" id="dfn-inherit-dictionary">inherit</dfn> from another dictionary.
If the identifier of the dictionary is followed by a colon and a <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-33">identifier</a>,
then that identifier identifies the inherited dictionary. The identifier
must identify a dictionary.</p>
<p>A dictionary must not be declared such that
its inheritance hierarchy has a cycle. That is, a dictionary <var>A</var> cannot inherit from itself, nor can it inherit from another
dictionary <var>B</var> that inherits from <var>A</var>, and so on.</p>
<pre class="syntax highlight"><span class="kt">dictionary</span> <mark><span class="nv">Base</span></mark> {
/* dictionary_members... */
};
<span class="kt">dictionary</span> <span class="nv">Derived</span> : <mark><span class="n">Base</span></mark> {
/* dictionary_members... */
};
</pre>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-inherited-dictionaries">inherited dictionaries</dfn> of
a given dictionary <var>D</var> is the set of all dictionaries that <var>D</var> inherits from, directly or indirectly. If <var>D</var> does not <a data-link-type="dfn" href="#dfn-inherit-dictionary" id="ref-for-dfn-inherit-dictionary-1">inherit</a> from another dictionary, then the set is empty. Otherwise, the set
includes the dictionary <var>E</var> that <var>D</var> <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-5">inherits</a> from and all of <var>E</var>’s <a data-link-type="dfn" href="#dfn-inherited-dictionaries" id="ref-for-dfn-inherited-dictionaries-1">inherited dictionaries</a>.</p>
<p>A dictionary value of type <var>D</var> can have key–value pairs corresponding
to the dictionary members defined on <var>D</var> and on any of <var>D</var>’s <a data-link-type="dfn" href="#dfn-inherited-dictionaries" id="ref-for-dfn-inherited-dictionaries-2">inherited dictionaries</a>.
On a given dictionary value, the presence of each dictionary member
is optional, unless that member is specified as required.
When specified in the dictionary value, a dictionary member is said to be <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-present">present</dfn>, otherwise it is <a data-link-type="dfn" href="#dfn-present" id="ref-for-dfn-present-1">not present</a>.
Dictionary members can also optionally have a <dfn class="dfn-paneled" data-dfn-for="dictionary member" data-dfn-type="dfn" data-export="" id="dfn-dictionary-member-default-value">default value</dfn>, which is
the value to use for the dictionary member when passing a value to a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-6">platform object</a> that does
not have a specified value. Dictionary members with default values are
always considered to be present.</p>
<p class="advisement"> As with <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-7">operation argument default values</a>,
is strongly suggested not to use of <emu-val>true</emu-val> as the <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-2">default value</a> for <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-5">boolean</a></code>-typed <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-4">dictionary members</a>,
as this can be confusing for authors who might otherwise expect the default
conversion of <emu-val>undefined</emu-val> to be used (i.e., <emu-val>false</emu-val>). </p>
<p>Each <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-5">dictionary member</a> (matching <emu-nt><a href="#prod-DictionaryMember">DictionaryMember</a></emu-nt>) is specified
as a type (matching <emu-nt><a href="#prod-Type">Type</a></emu-nt>) followed by an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-34">identifier</a> (given by an <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token following
the type). The identifier is the key name of the key–value pair.
If the <emu-nt><a href="#prod-Type">Type</a></emu-nt> is an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-35">identifier</a> followed by <code>?</code>, then the identifier
must identify an
interface, <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-10">enumeration</a>, <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-13">callback function</a> or <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-10">typedef</a>.
If the dictionary member type is an identifier
not followed by <code>?</code>, then the identifier must
identify any one of those definitions or a <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-9">dictionary</a>.</p>
<pre class="syntax highlight"><span class="kt">dictionary</span> <span class="nv">identifier</span> {
<span class="n">type</span> <span class="nv">identifier</span>;
};
</pre>
<p>If the identifier is followed by a <span class="char">U+003D EQUALS SIGN ("=")</span> and a value (matching <emu-nt><a href="#prod-DefaultValue">DefaultValue</a></emu-nt>),
then that gives the dictionary member its <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-3">default value</a>.</p>
<pre class="syntax highlight"><span class="kt">dictionary</span> <span class="nv">identifier</span> {
<span class="n">type</span> <span class="nv">identifier</span> = "value";
};
</pre>
<p>When a boolean literal token (<code>true</code> or <code>false</code>),
the <code>null</code> token,
an <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> token, a <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> token,
one of the three special floating point literal values (<code>Infinity</code>, <code>-Infinity</code> or <code>NaN</code>),
a <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> token or
the two token sequence <code>[]</code> used as the <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-4">default value</a>,
it is interpreted in the same way as for an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-20">operation</a>’s <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-8">optional argument default value</a>.</p>
<p>If the type of the <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-6">dictionary member</a> is an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-11">enumeration</a>, then its <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-5">default value</a> if specified must
be one of the <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-2">enumeration’s values</a>.</p>
<p>If the type of the dictionary member is preceded by the <code>required</code> keyword, the member is considered a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="required-dictionary-member">required dictionary member</dfn> and must be present on the dictionary. A <a data-link-type="dfn" href="#required-dictionary-member" id="ref-for-required-dictionary-member-2">required dictionary member</a> must not have a default value.</p>
<pre class="syntax highlight"><span class="kt">dictionary</span> <span class="nv">identifier</span> {
<span class="kt">required</span> <span class="n">type</span> <span class="nv">identifier</span>;
};
</pre>
<p>The type of a dictionary member must not include
the dictionary it appears on. A type includes a dictionary <var>D</var> if at least one of the following is true:</p>
<ul>
<li data-md="">
<p>the type is <var>D</var></p>
<li data-md="">
<p>the type is a dictionary that <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-6">inherits</a> from <var>D</var></p>
<li data-md="">
<p>the type is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-8">nullable type</a> whose <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-4">inner type</a> includes <var>D</var></p>
<li data-md="">
<p>the type is a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-4">sequence type</a> or <a data-link-type="dfn" href="#dfn-frozen-array-type" id="ref-for-dfn-frozen-array-type-1">frozen array</a> whose element type includes <var>D</var></p>
<li data-md="">
<p>the type is a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-6">union type</a>,
one of whose <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-3">member types</a> includes <var>D</var></p>
<li data-md="">
<p>the type is a dictionary, one of whose members or inherited members has
a type that includes <var>D</var></p>
</ul>
<p>As with interfaces, the IDL for dictionaries can be split into multiple parts
by using <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-partial-dictionary">partial dictionary</dfn> definitions
(matching <emu-t>partial</emu-t> <emu-nt><a href="#prod-Dictionary">Dictionary</a></emu-nt>).
The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-36">identifier</a> of a partial
dictionary definition must be the same as the
identifier of a dictionary definition. All of the members that appear on each
of the partial dictionary definitions are considered to be members of
the dictionary itself.</p>
<pre class="syntax highlight"><span class="kt">dictionary</span> <mark><span class="nv">SomeDictionary</span></mark> {
/* dictionary_members... */
};
<span class="kt">partial</span> <span class="kt">dictionary</span> <mark><span class="nv">SomeDictionary</span></mark> {
/* dictionary_members... */
};
</pre>
<p class="note" role="note">Note: As with partial interface definitions, partial dictionary definitions are intended for use as a specification
editorial aide, allowing the definition of an interface to be separated
over more than one section of the document, and sometimes multiple documents.</p>
<p>The order of the <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-7">dictionary members</a> on a given dictionary is such that inherited dictionary members are ordered
before non-inherited members, and the dictionary members on the one
dictionary definition (including any partial dictionary definitions) are
ordered lexicographically by the Unicode codepoints that comprise their
identifiers.</p>
<div class="note" role="note">
<p>For example, with the following definitions:</p>
<pre class="highlight"><span class="kt">dictionary</span> <span class="nv">B</span> : <span class="n">A</span> {
<span class="kt">long</span> <span class="nv">b</span>;
<span class="kt">long</span> <span class="nv">a</span>;
};
<span class="kt">dictionary</span> <span class="nv">A</span> {
<span class="kt">long</span> <span class="nv">c</span>;
<span class="kt">long</span> <span class="nv">g</span>;
};
<span class="kt">dictionary</span> <span class="nv">C</span> : <span class="n">B</span> {
<span class="kt">long</span> <span class="nv">e</span>;
<span class="kt">long</span> <span class="nv">f</span>;
};
<span class="kt">partial</span> <span class="kt">dictionary</span> <span class="nv">A</span> {
<span class="kt">long</span> <span class="nv">h</span>;
<span class="kt">long</span> <span class="nv">d</span>;
};
</pre>
<p>the order of the <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-8">dictionary members</a> of a dictionary value of type <code class="idl">C</code> is
c, d, g, h, a, b, e, f.</p>
<p>Dictionaries are required to have their members ordered because
in some language bindings the behavior observed when passing
a dictionary value to a platform object depends on the order
the dictionary members are fetched. For example, consider the
following additional interface:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Something</span> {
<span class="kt">void</span> <span class="nv">f</span>(<span class="n">A</span> <span class="nv">a</span>);
};
</pre>
<p>and this ECMAScript code:</p>
<pre class="highlight"><span class="kd">var</span> something <span class="o">=</span> getSomething<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of Something.
</span><span class="kd">var</span> x <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="kd">var</span> dict <span class="o">=</span> <span class="p">{</span> <span class="p">}</span><span class="p">;</span>
Object<span class="p">.</span>defineProperty<span class="p">(</span>dict<span class="p">,</span> <span class="s2">"d"</span><span class="p">,</span> <span class="p">{</span> get<span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="o">++</span>x<span class="p">;</span> <span class="p">}</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span>
Object<span class="p">.</span>defineProperty<span class="p">(</span>dict<span class="p">,</span> <span class="s2">"c"</span><span class="p">,</span> <span class="p">{</span> get<span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="o">++</span>x<span class="p">;</span> <span class="p">}</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span>
something<span class="p">.</span>f<span class="p">(</span>dict<span class="p">)</span><span class="p">;</span>
</pre>
<p>The order that the dictionary members are fetched in determines
what values they will be taken to have. Since the order for <code class="idl">A</code> is defined to be c then d,
the value for c will be 1 and the value for d will be 2.</p>
</div>
<p>The identifier of a dictionary member must not be
the same as that of another dictionary member defined on the dictionary or
on that dictionary’s <a data-link-type="dfn" href="#dfn-inherited-dictionaries" id="ref-for-dfn-inherited-dictionaries-3">inherited dictionaries</a>.</p>
<p>Dictionaries must not be used as the type of an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-14">attribute</a> or <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-15">constant</a>.</p>
<p>The following extended attributes are applicable to dictionaries:
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-10">Constructor</a></code>],
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-8">Exposed</a></code>],
[<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-8">SecureContext</a></code>],</p>
<p>The following extended attributes are applicable to dictionary members:
[<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-3">Clamp</a></code>],
[<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-3">EnforceRange</a></code>].</p>
<div data-fill-with="grammar-Partial"></div>
<div data-fill-with="grammar-PartialDefinition"></div>
<pre class="grammar" id="prod-Dictionary">Dictionary :
"dictionary" identifier Inheritance "{" DictionaryMembers "}" ";"
</pre>
<pre class="grammar" id="prod-DictionaryMembers">DictionaryMembers :
ExtendedAttributeList DictionaryMember DictionaryMembers
ε
</pre>
<pre class="grammar" id="prod-DictionaryMember">DictionaryMember :
Required Type identifier Default ";"
</pre>
<pre class="grammar" id="prod-Required">Required :
"required"
ε
</pre>
<pre class="grammar" id="prod-PartialDictionary">PartialDictionary :
"dictionary" identifier "{" DictionaryMembers "}" ";"
</pre>
<pre class="grammar" id="prod-Default">Default :
"=" DefaultValue
ε
</pre>
<div data-fill-with="grammar-DefaultValue"></div>
<div data-fill-with="grammar-Inheritance"></div>
<div class="example" id="example-63b9e2f7">
<a class="self-link" href="#example-63b9e2f7"></a>
<p>One use of dictionary types is to allow a number of optional arguments to
an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-21">operation</a> without being
constrained as to the order they are specified at the call site. For example,
consider the following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-25">IDL fragment</a>:</p>
<pre class="highlight">[<span class="nv">Constructor</span>]
<span class="kt">interface</span> <span class="nv">Point</span> {
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">x</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">y</span>;
};
<span class="kt">dictionary</span> <span class="nv">PaintOptions</span> {
<span class="kt">DOMString</span>? <span class="nv">fillPattern</span> = "black";
<span class="kt">DOMString</span>? <span class="nv">strokePattern</span> = <span class="kt">null</span>;
<span class="n">Point</span> <span class="nv">position</span>;
};
<span class="kt">interface</span> <span class="nv">GraphicsContext</span> {
<span class="kt">void</span> <span class="nv">drawRectangle</span>(<span class="kt">double</span> <span class="nv">width</span>, <span class="kt">double</span> <span class="nv">height</span>, <span class="kt">optional</span> <span class="n">PaintOptions</span> <span class="nv">options</span>);
};
</pre>
<p>In an ECMAScript implementation of the IDL, an <emu-val>Object</emu-val> can be passed in for the optional <code class="idl">PaintOptions</code> dictionary:</p>
<pre class="highlight"><span class="c1">// Get an instance of GraphicsContext.
</span><span class="kd">var</span> ctx <span class="o">=</span> getGraphicsContext<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Draw a rectangle.
</span>ctx<span class="p">.</span>drawRectangle<span class="p">(</span><span class="mi">300</span><span class="p">,</span> <span class="mi">200</span><span class="p">,</span> <span class="p">{</span> fillPattern<span class="o">:</span> <span class="s2">"red"</span><span class="p">,</span> position<span class="o">:</span> <span class="k">new</span> Point<span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span>
</pre>
<p>Both fillPattern and strokePattern are given <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-6">default values</a>,
so if they are omitted, the definition of drawRectangle can assume that they
have the given default values and not include explicit wording to handle
their non-presence.</p>
</div>
<h3 class="heading settled" data-level="2.5" id="idl-exceptions"><span class="secno">2.5. </span><span class="content">Exceptions</span><a class="self-link" href="#idl-exceptions"></a></h3>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-exception">exception</dfn> is a type of object that
represents an error and which can be thrown or treated as a first
class value by implementations. Web IDL does not allow exceptions
to be defined, but instead has a number of pre-defined exceptions
that specifications can reference and throw in their definition of
operations, attributes, and so on. Exceptions have an <dfn class="dfn-paneled" data-dfn-for="exception" data-dfn-type="dfn" data-export="" id="dfn-exception-error-name">error name</dfn>,
a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-16">DOMString</a></code>,
which is the type of error the exception represents, and a <dfn data-dfn-for="exception" data-dfn-type="dfn" data-export="" id="dfn-exception-message">message<a class="self-link" href="#dfn-exception-message"></a></dfn>, which is an optional,
user agent-defined value that provides human readable details of the error.</p>
<p>There are two kinds of exceptions available to be thrown from specifications.
The first is a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-simple-exception">simple exception</dfn>, which
is identified by one of the following names:</p>
<ul>
<li data-md="">
<p>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="exceptiondef-error"><code>Error</code><a class="self-link" href="#exceptiondef-error"></a></dfn>"</p>
<li data-md="">
<p>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="exceptiondef-evalerror"><code>EvalError</code><a class="self-link" href="#exceptiondef-evalerror"></a></dfn>"</p>
<li data-md="">
<p>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="exceptiondef-rangeerror"><code>RangeError</code><a class="self-link" href="#exceptiondef-rangeerror"></a></dfn>"</p>
<li data-md="">
<p>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="exceptiondef-referenceerror"><code>ReferenceError</code><a class="self-link" href="#exceptiondef-referenceerror"></a></dfn>"</p>
<li data-md="">
<p>"<dfn class="dfn-paneled idl-code" data-dfn-type="exception" data-export="" id="exceptiondef-typeerror"><code>TypeError</code></dfn>"</p>
<li data-md="">
<p>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="exceptiondef-urierror"><code>URIError</code><a class="self-link" href="#exceptiondef-urierror"></a></dfn>"</p>
</ul>
<p>These correspond to all of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-error-objects">ECMAScript error objects</a> (apart from <emu-val>SyntaxError</emu-val>, which is deliberately omitted as
it is for use only by the ECMAScript parser).
The meaning of
each <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-1">simple exception</a> matches
its corresponding <emu-val>Error</emu-val> object in the
ECMAScript specification.</p>
<p>The second kind of exception is a <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="dfn-DOMException">DOMException</dfn>,
which is an exception that encapsulates a name and an optional integer code,
for compatibility with historically defined exceptions in the DOM.</p>
<p>For <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-2">simple exceptions</a>,
the <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-1">error name</a> is the name
of the exception.
For a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-1">DOMException</a></code>,
the <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-2">error name</a> must
be one of the names listed in the <a data-link-type="dfn" href="#dfn-error-names-table" id="ref-for-dfn-error-names-table-1">error names table</a> below. The table also indicates the <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-2">DOMException</a></code>'s integer code
for that error name, if it has one.</p>
<p>There are two types that can be used to refer to
exception objects: <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-1">Error</a></code>, which encompasses all exceptions,
and <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-3">DOMException</a></code> which includes just DOMException objects.
This allows for example an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-22">operation</a> to be declared to have a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-4">DOMException</a></code> <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-2">return type</a> or an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-15">attribute</a> to be of type <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-2">Error</a></code>.</p>
<p>Exceptions can be <dfn class="dfn-paneled" data-dfn-for="exception" data-dfn-type="dfn" data-export="" id="dfn-create-exception">created</dfn> by providing its <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-3">error name</a>.
Exceptions can also be <dfn class="dfn-paneled" data-dfn-for="exception" data-dfn-type="dfn" data-export="" data-lt="throw|thrown" id="dfn-throw">thrown</dfn>, by providing the
same details required to <a data-link-type="dfn" href="#dfn-create-exception" id="ref-for-dfn-create-exception-1">create</a> one.</p>
<p>The resulting behavior from creating and throwing an exception is language binding-specific.</p>
<p class="note" role="note">Note: See <a href="#es-creating-throwing-exceptions">§3.14 Creating and throwing exceptions</a> for details on what creating and throwing an exception
entails in the ECMAScript language binding.</p>
<div class="example" id="example-e7863d09">
<a class="self-link" href="#example-e7863d09"></a>
<p>Here is are some examples of wording to use to create and throw exceptions.
To throw a new <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-3">simple exception</a> named <code class="idl"><a data-link-type="idl" href="#exceptiondef-typeerror" id="ref-for-exceptiondef-typeerror-1">TypeError</a></code>:</p>
<blockquote>
<p><a data-link-type="dfn" href="#dfn-throw" id="ref-for-dfn-throw-1">Throw</a> a TypeError.</p>
</blockquote>
<p>To throw a new <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-5">DOMException</a></code> with <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-4">error name</a> <code class="idl"><a data-link-type="idl" href="#indexsizeerror" id="ref-for-indexsizeerror-1">IndexSizeError</a></code>:</p>
<blockquote>
<p><a data-link-type="dfn" href="#dfn-throw" id="ref-for-dfn-throw-2">Throw</a> an IndexSizeError.</p>
</blockquote>
<p>To create a new <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-6">DOMException</a></code> with <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-5">error name</a> <code class="idl"><a data-link-type="idl" href="#syntaxerror" id="ref-for-syntaxerror-1">SyntaxError</a></code>:</p>
<blockquote>
<p>Let <var>object</var> be a newly <a data-link-type="dfn" href="#dfn-create-exception" id="ref-for-dfn-create-exception-2">created</a> SyntaxError.</p>
</blockquote>
</div>
<h4 class="heading settled" data-level="2.5.1" id="idl-DOMException-error-names"><span class="secno">2.5.1. </span><span class="content">Error names</span><a class="self-link" href="#idl-DOMException-error-names"></a></h4>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-error-names-table">error names table</dfn> below lists all the allowed error names
for <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-7">DOMExceptions</a></code>, a description,
and legacy code values.</p>
<p class="note" role="note">Note: If an error name is not listed here, please file a bug as indicated at the top of this specification and it will be addressed shortly. Thanks!</p>
<table class="vert data" id="error-names">
<thead>
<tr>
<th>Name
<th>Description
<th>Legacy <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-8">code</a></code> name and value
<tbody>
<tr>
<td>"<dfn class="dfn-paneled idl-code" data-dfn-type="exception" data-export="" id="indexsizeerror"><code>IndexSizeError</code></dfn>"
<td>The index is not in the allowed range.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-index_size_err"><code>INDEX_SIZE_ERR</code><a class="self-link" href="#dom-domexception-index_size_err"></a></dfn> (1)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="hierarchyrequesterror"><code>HierarchyRequestError</code><a class="self-link" href="#hierarchyrequesterror"></a></dfn>"
<td>The operation would yield an incorrect <a href="https://dom.spec.whatwg.org/#concept-node-tree" title="concept-node-tree">node tree</a>.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-hierarchy_request_err"><code>HIERARCHY_REQUEST_ERR</code><a class="self-link" href="#dom-domexception-hierarchy_request_err"></a></dfn> (3)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="wrongdocumenterror"><code>WrongDocumentError</code><a class="self-link" href="#wrongdocumenterror"></a></dfn>"
<td>The object is in the wrong <a href="https://dom.spec.whatwg.org/#concept-document" title="concept-document">document</a>.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-wrong_document_err"><code>WRONG_DOCUMENT_ERR</code><a class="self-link" href="#dom-domexception-wrong_document_err"></a></dfn> (4)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="invalidcharactererror"><code>InvalidCharacterError</code><a class="self-link" href="#invalidcharactererror"></a></dfn>"
<td>The string contains invalid characters.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-invalid_character_err"><code>INVALID_CHARACTER_ERR</code><a class="self-link" href="#dom-domexception-invalid_character_err"></a></dfn> (5)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="nomodificationallowederror"><code>NoModificationAllowedError</code><a class="self-link" href="#nomodificationallowederror"></a></dfn>"
<td>The object can not be modified.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-no_modification_allowed_err"><code>NO_MODIFICATION_ALLOWED_ERR</code><a class="self-link" href="#dom-domexception-no_modification_allowed_err"></a></dfn> (7)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="notfounderror"><code>NotFoundError</code><a class="self-link" href="#notfounderror"></a></dfn>"
<td>The object can not be found here.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-not_found_err"><code>NOT_FOUND_ERR</code><a class="self-link" href="#dom-domexception-not_found_err"></a></dfn> (8)
<tr>
<td>"<dfn class="dfn-paneled idl-code" data-dfn-type="exception" data-export="" id="notsupportederror"><code>NotSupportedError</code></dfn>"
<td>The operation is not supported.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-not_supported_err"><code>NOT_SUPPORTED_ERR</code><a class="self-link" href="#dom-domexception-not_supported_err"></a></dfn> (9)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="inuseattributeerror"><code>InUseAttributeError</code><a class="self-link" href="#inuseattributeerror"></a></dfn>"
<td>The attribute is in use.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-inuse_attribute_err"><code>INUSE_ATTRIBUTE_ERR</code><a class="self-link" href="#dom-domexception-inuse_attribute_err"></a></dfn> (10)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="invalidstateerror"><code>InvalidStateError</code><a class="self-link" href="#invalidstateerror"></a></dfn>"
<td>The object is in an invalid state.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-invalid_state_err"><code>INVALID_STATE_ERR</code><a class="self-link" href="#dom-domexception-invalid_state_err"></a></dfn> (11)
<tr>
<td>"<dfn class="dfn-paneled idl-code" data-dfn-type="exception" data-export="" id="syntaxerror"><code>SyntaxError</code></dfn>"
<td>The string did not match the expected pattern.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-syntax_err"><code>SYNTAX_ERR</code><a class="self-link" href="#dom-domexception-syntax_err"></a></dfn> (12)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="invalidmodificationerror"><code>InvalidModificationError</code><a class="self-link" href="#invalidmodificationerror"></a></dfn>"
<td>The object can not be modified in this way.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-invalid_modification_err"><code>INVALID_MODIFICATION_ERR</code><a class="self-link" href="#dom-domexception-invalid_modification_err"></a></dfn> (13)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="namespaceerror"><code>NamespaceError</code><a class="self-link" href="#namespaceerror"></a></dfn>"
<td>The operation is not allowed by <cite>Namespaces in XML</cite>. <a data-link-type="biblio" href="#biblio-xml-names">[XML-NAMES]</a>
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-namespace_err"><code>NAMESPACE_ERR</code><a class="self-link" href="#dom-domexception-namespace_err"></a></dfn> (14)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="invalidaccesserror"><code>InvalidAccessError</code><a class="self-link" href="#invalidaccesserror"></a></dfn>"
<td>The object does not support the operation or argument.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-invalid_access_err"><code>INVALID_ACCESS_ERR</code><a class="self-link" href="#dom-domexception-invalid_access_err"></a></dfn> (15)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="securityerror"><code>SecurityError</code><a class="self-link" href="#securityerror"></a></dfn>"
<td>The operation is insecure.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-security_err"><code>SECURITY_ERR</code><a class="self-link" href="#dom-domexception-security_err"></a></dfn> (18)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="networkerror"><code>NetworkError</code><a class="self-link" href="#networkerror"></a></dfn>"
<td>A network error occurred.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-network_err"><code>NETWORK_ERR</code><a class="self-link" href="#dom-domexception-network_err"></a></dfn> (19)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="aborterror"><code>AbortError</code><a class="self-link" href="#aborterror"></a></dfn>"
<td>The operation was aborted.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-abort_err"><code>ABORT_ERR</code><a class="self-link" href="#dom-domexception-abort_err"></a></dfn> (20)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="urlmismatcherror"><code>URLMismatchError</code><a class="self-link" href="#urlmismatcherror"></a></dfn>"
<td>The given URL does not match another URL.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-url_mismatch_err"><code>URL_MISMATCH_ERR</code><a class="self-link" href="#dom-domexception-url_mismatch_err"></a></dfn> (21)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="quotaexceedederror"><code>QuotaExceededError</code><a class="self-link" href="#quotaexceedederror"></a></dfn>"
<td>The quota has been exceeded.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-quota_exceeded_err"><code>QUOTA_EXCEEDED_ERR</code><a class="self-link" href="#dom-domexception-quota_exceeded_err"></a></dfn> (22)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="timeouterror"><code>TimeoutError</code><a class="self-link" href="#timeouterror"></a></dfn>"
<td>The operation timed out.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-timeout_err"><code>TIMEOUT_ERR</code><a class="self-link" href="#dom-domexception-timeout_err"></a></dfn> (23)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="invalidnodetypeerror"><code>InvalidNodeTypeError</code><a class="self-link" href="#invalidnodetypeerror"></a></dfn>"
<td>The supplied node is incorrect or has an incorrect ancestor for this operation.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-invalid_node_type_err"><code>INVALID_NODE_TYPE_ERR</code><a class="self-link" href="#dom-domexception-invalid_node_type_err"></a></dfn> (24)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="datacloneerror"><code>DataCloneError</code><a class="self-link" href="#datacloneerror"></a></dfn>"
<td>The object can not be cloned.
<td><dfn class="idl-code" data-dfn-for="DOMException" data-dfn-type="const" data-export="" id="dom-domexception-data_clone_err"><code>DATA_CLONE_ERR</code><a class="self-link" href="#dom-domexception-data_clone_err"></a></dfn> (25)
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="encodingerror"><code>EncodingError</code><a class="self-link" href="#encodingerror"></a></dfn>"
<td>The encoding operation (either encoded or decoding) failed.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="notreadableerror"><code>NotReadableError</code><a class="self-link" href="#notreadableerror"></a></dfn>"
<td>The I/O read operation failed.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="unknownerror"><code>UnknownError</code><a class="self-link" href="#unknownerror"></a></dfn>"
<td>The operation failed for an unknown transient reason (e.g. out of memory).
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="constrainterror"><code>ConstraintError</code><a class="self-link" href="#constrainterror"></a></dfn>"
<td>A mutation operation in a transaction failed because a constraint was not satisfied.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="dataerror"><code>DataError</code><a class="self-link" href="#dataerror"></a></dfn>"
<td>Provided data is inadequate.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="transactioninactiveerror"><code>TransactionInactiveError</code><a class="self-link" href="#transactioninactiveerror"></a></dfn>"
<td>A request was placed against a transaction which is currently not active, or which is finished.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="readonlyerror"><code>ReadOnlyError</code><a class="self-link" href="#readonlyerror"></a></dfn>"
<td>The mutating operation was attempted in a "readonly" transaction.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="versionerror"><code>VersionError</code><a class="self-link" href="#versionerror"></a></dfn>"
<td>An attempt was made to open a database using a lower version than the existing version.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="operationerror"><code>OperationError</code><a class="self-link" href="#operationerror"></a></dfn>"
<td>The operation failed for an operation-specific reason.
<td>—
<tr>
<td>"<dfn class="idl-code" data-dfn-type="exception" data-export="" id="notallowederror"><code>NotAllowedError</code><a class="self-link" href="#notallowederror"></a></dfn>"
<td>The request is not allowed by the user agent or the platform in the current context, possibly because the user denied permission.
<td>—
</table>
<h3 class="heading settled" data-level="2.6" id="idl-enums"><span class="secno">2.6. </span><span class="content">Enumerations</span><a class="self-link" href="#idl-enums"></a></h3>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-enumeration">enumeration</dfn> is a definition (matching <emu-nt><a href="#prod-Enum">Enum</a></emu-nt>) used to declare a type
whose valid values are a set of predefined strings. Enumerations
can be used to restrict the possible <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-17">DOMString</a></code> values that can be assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-16">attribute</a> or passed to an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-23">operation</a>.</p>
<pre class="syntax highlight"><span class="kt">enum</span> <span class="nv">identifier</span> { <span class="s">"enum"</span>, <span class="s">"values"</span> /* , ... */ };</pre>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="enumeration value" id="dfn-enumeration-value">enumeration values</dfn> are specified
as a comma-separated list of <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> literals.
The list of <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-3">enumeration values</a> must not include duplicates.</p>
<p class="advisement"> It is strongly suggested that enumeration values be all lowercase,
and that multiple words be separated using dashes or not be
separated at all, unless there is a specific reason to use another
value naming scheme. For example, an enumeration value that
indicates an object should be created could be named <code>"createobject"</code> or <code>"create-object"</code>.
Consider related uses of enumeration values when deciding whether
to dash-separate or not separate enumeration value words so that
similar APIs are consistent. </p>
<p>The behavior when a string value that is not one a valid enumeration value
is used when assigning to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-17">attribute</a>,
or passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-24">operation</a> argument,
whose type is the enumeration, is language binding specific.</p>
<p class="note" role="note">Note: In the ECMAScript binding, assignment of an invalid string value to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-18">attribute</a> is ignored, while
passing such a value as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-25">operation</a> argument
results in an exception being thrown.</p>
<p>No <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-18">extended attributes</a> defined in this specification are applicable to <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-12">enumerations</a>.</p>
<pre class="grammar" id="prod-Enum">Enum :
"enum" identifier "{" EnumValueList "}" ";"
</pre>
<pre class="grammar" id="prod-EnumValueList">EnumValueList :
string EnumValueListComma
</pre>
<pre class="grammar" id="prod-EnumValueListComma">EnumValueListComma :
"," EnumValueListString
ε
</pre>
<pre class="grammar" id="prod-EnumValueListString">EnumValueListString :
string EnumValueListComma
ε
</pre>
<div class="example" id="example-363ff014">
<a class="self-link" href="#example-363ff014"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-26">IDL fragment</a> defines an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-13">enumeration</a> that is used as the type of an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-19">attribute</a> and an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-26">operation</a> argument:</p>
<pre class="highlight"><span class="kt">enum</span> <span class="nv">MealType</span> { <span class="s">"rice"</span>, <span class="s">"noodles"</span>, <span class="s">"other"</span> };
<span class="kt">interface</span> <span class="nv">Meal</span> {
<span class="kt">attribute</span> <span class="n">MealType</span> <span class="nv">type</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">size</span>; // in grams
<span class="kt">void</span> <span class="nv">initialize</span>(<span class="n">MealType</span> <span class="nv">type</span>, <span class="kt">double</span> <span class="nv">size</span>);
};
</pre>
<p>An ECMAScript implementation would restrict the strings that can be
assigned to the type property or passed to the initializeMeal function
to those identified in the <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-14">enumeration</a>.</p>
<pre class="highlight"><span class="kd">var</span> meal <span class="o">=</span> getMeal<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of Meal.
</span>
meal<span class="p">.</span>initialize<span class="p">(</span><span class="s2">"rice"</span><span class="p">,</span> <span class="mi">200</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Operation invoked as normal.
</span>
<span class="k">try</span> <span class="p">{</span>
meal<span class="p">.</span>initialize<span class="p">(</span><span class="s2">"sandwich"</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Throws a TypeError.
</span><span class="p">}</span> <span class="k">catch</span> <span class="p">(</span>e<span class="p">)</span> <span class="p">{</span>
<span class="p">}</span>
meal<span class="p">.</span>type <span class="o">=</span> <span class="s2">"noodles"</span><span class="p">;</span> <span class="c1">// Attribute assigned as normal.
</span>meal<span class="p">.</span>type <span class="o">=</span> <span class="s2">"dumplings"</span><span class="p">;</span> <span class="c1">// Attribute assignment ignored.
</span>meal<span class="p">.</span>type <span class="o">==</span> <span class="s2">"noodles"</span><span class="p">;</span> <span class="c1">// Evaluates to true.
</span></pre>
</div>
<h3 class="heading settled" data-level="2.7" id="idl-callback-functions"><span class="secno">2.7. </span><span class="content">Callback functions</span><a class="self-link" href="#idl-callback-functions"></a></h3>
<p class="issue" id="issue-2731c18f"><a class="self-link" href="#issue-2731c18f"></a> The “Custom DOM Elements” spec wants to use callback function types for
platform object provided functions. Should we rename “callback functions” to
just “functions” to make it clear that they can be used for both purposes? </p>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-callback-function">callback function</dfn> is a definition (matching <emu-t>callback</emu-t> <emu-nt><a href="#prod-CallbackRest">CallbackRest</a></emu-nt>) used to declare a function type.</p>
<pre class="syntax highlight"><span class="kt">callback</span> <span class="nv">identifier</span> = <span class="n">return_type</span> (/* arguments... */);</pre>
<p class="note" role="note">Note: See also the similarly named <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-11">callback interfaces</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-37">identifier</a> on the
left of the equals sign gives the name of the <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-14">callback function</a> and the return type and argument list (matching <emu-nt><a href="#prod-ReturnType">ReturnType</a></emu-nt> and <emu-nt><a href="#prod-ArgumentList">ArgumentList</a></emu-nt>) on the right side of the equals
sign gives the signature of the callback function type.</p>
<p><a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-15">Callback functions</a> must not
be used as the type of a <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-16">constant</a>.</p>
<p>The following extended attribute is applicable to callback functions:
[<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-1">TreatNonObjectAsNull</a></code>].</p>
<div data-fill-with="grammar-CallbackOrInterface"></div>
<div data-fill-with="grammar-CallbackRestOrInterface"></div>
<pre class="grammar" id="prod-CallbackRest">CallbackRest :
identifier "=" ReturnType "(" ArgumentList ")" ";"
</pre>
<div class="example" id="example-28a54335">
<a class="self-link" href="#example-28a54335"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-27">IDL fragment</a> defines
a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-16">callback function</a> used for an API that
invokes a user-defined function when an operation is complete.</p>
<pre class="highlight"><span class="kt">callback</span> <span class="nv">AsyncOperationCallback</span> = <span class="kt">void</span> (<span class="kt">DOMString</span> <span class="nv">status</span>);
<span class="kt">interface</span> <span class="nv">AsyncOperations</span> {
<span class="kt">void</span> <span class="nv">performOperation</span>(<span class="n">AsyncOperationCallback</span> <span class="nv">whenFinished</span>);
};
</pre>
<p>In the ECMAScript language binding, a <emu-val>Function</emu-val> object is
passed as the operation argument.</p>
<pre class="highlight"><span class="kd">var</span> ops <span class="o">=</span> getAsyncOperations<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of AsyncOperations.
</span>
ops<span class="p">.</span>performOperation<span class="p">(</span><span class="kd">function</span><span class="p">(</span>status<span class="p">)</span> <span class="p">{</span>
window<span class="p">.</span>alert<span class="p">(</span><span class="s2">"Operation finished, status is "</span> <span class="o">+</span> status <span class="o">+</span> <span class="s2">"."</span><span class="p">)</span><span class="p">;</span>
<span class="p">}</span><span class="p">)</span><span class="p">;</span>
</pre>
</div>
<h3 class="heading settled" data-level="2.8" id="idl-typedefs"><span class="secno">2.8. </span><span class="content">Typedefs</span><a class="self-link" href="#idl-typedefs"></a></h3>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-typedef">typedef</dfn> is a definition (matching <emu-nt><a href="#prod-Typedef">Typedef</a></emu-nt>)
used to declare a new name for a type. This new name is not exposed
by language bindings; it is purely used as a shorthand for referencing
the type in the IDL.</p>
<pre class="syntax highlight"><span class="kt">typedef</span> <span class="n">type</span> <span class="nv">identifier</span>;</pre>
<p>The type being given a new name is specified after the <code>typedef</code> keyword (matching <emu-nt><a href="#prod-Type">Type</a></emu-nt>), and the <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> token following the
type gives the name.</p>
<p>The <emu-nt><a href="#prod-Type">Type</a></emu-nt> must not
identify the same or another <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-11">typedef</a>.</p>
<p>No <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-19">extended attributes</a> defined in this specification are applicable to <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-12">typedefs</a>.</p>
<pre class="grammar" id="prod-Typedef">Typedef :
"typedef" Type identifier ";"
</pre>
<div class="example" id="example-89793fdc">
<a class="self-link" href="#example-89793fdc"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-28">IDL fragment</a> demonstrates the use of <a data-link-type="dfn" href="#dfn-typedef" id="ref-for-dfn-typedef-13">typedefs</a> to allow the use of a short <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-38">identifier</a> instead of a long <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-5">sequence type</a>.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Point</span> {
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">x</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">y</span>;
};
<span class="kt">typedef</span> <span class="kt">sequence</span><<span class="n">Point</span>> <span class="nv">Points</span>;
<span class="kt">interface</span> <span class="nv">Widget</span> {
<span class="kt">boolean</span> <span class="nv">pointWithinBounds</span>(<span class="n">Point</span> <span class="nv">p</span>);
<span class="kt">boolean</span> <span class="nv">allPointsWithinBounds</span>(<span class="n">Points</span> <span class="nv">ps</span>);
};
</pre>
</div>
<h3 class="heading settled" data-level="2.9" id="idl-implements-statements"><span class="secno">2.9. </span><span class="content">Implements statements</span><a class="self-link" href="#idl-implements-statements"></a></h3>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-implements-statement">implements statement</dfn> is a definition
(matching <emu-nt><a href="#prod-ImplementsStatement">ImplementsStatement</a></emu-nt>)
used to declare that all objects implementing an interface <var>A</var> (identified by the first <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-39">identifier</a>)
must additionally implement interface <var>B</var> (identified by the second identifier), including all other interfaces that <var>B</var> inherits from.</p>
<pre class="syntax highlight"><span class="n">identifier_A</span> <span class="kt">implements</span> <span class="n">identifier_B</span>;</pre>
<p>Transitively, if objects implementing <var>B</var> are declared with an <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-3">implements statement</a> to additionally implement interface <var>C</var>, then all objects implementing <var>A</var> do additionally implement interface <var>C</var>.</p>
<p>The two <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-40">identifiers</a> must
identify two different interfaces.</p>
<p>The interface identified on the left-hand side of an implements statement
must not <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-7">inherit</a> from the interface identifier on the right-hand side, and vice versa. Both identified
interfaces also must not be <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-12">callback interfaces</a>.</p>
<p>If each <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-4">implements statement</a> is
considered to be an edge in a directed graph, from a node representing the interface
on the left-hand side of the statement to a node representing the interface on the
right-hand side, then this graph must not have any cycles.</p>
<p>Interfaces that a given object implements are partitioned into those that are considered <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="supplemental interface" id="dfn-supplemental-interface">supplemental interfaces</dfn> and those that are not.
An interface <var>A</var> is considered to be a <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-1">supplemental interface</a> of an object <var>O</var> if:</p>
<ul>
<li data-md="">
<p><var>O</var> implements a different interface <var>B</var>, and the IDL states that <code>B implements A</code>; or</p>
<li data-md="">
<p><var>O</var> implements a different <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-2">supplemental interface</a> <var>C</var>, and <var>C</var> <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-8">inherits</a> from <var>A</var>.</p>
</ul>
<div class="note" role="note">
<p>Specification authors are discouraged from writing <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-5">implements statements</a> where the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-47">interface</a> on the left-hand side
is a <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-3">supplemental interface</a>.
For example, if author 1 writes:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Window</span> { /* ... */ };
<span class="kt">interface</span> <span class="nv">SomeFunctionality</span> { /* ... */ };
<span class="n">Window</span> <span class="kt">implements</span> <span class="n">SomeFunctionality</span>;
</pre>
<p>and author 2 later writes:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Gizmo</span> { /* ... */ };
<span class="kt">interface</span> <span class="nv">MoreFunctionality</span> { /* ... */ };
<span class="n">SomeFunctionality</span> <span class="kt">implements</span> <span class="n">MoreFunctionality</span>;
<span class="n">Gizmo</span> <span class="kt">implements</span> <span class="n">SomeFunctionality</span>;
</pre>
<p>then it might be the case that author 2 is unaware of exactly which
interfaces already are used on the left-hand side of an <code>implements SomeFunctionality</code> statement, and so has
required more objects implement <code class="idl">MoreFunctionality</code> than he or she expected.</p>
<p>Better in this case would be for author 2 to write:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Gizmo</span> { /* ... */ };
<span class="kt">interface</span> <span class="nv">MoreFunctionality</span> { /* ... */ };
<span class="n">Gizmo</span> <span class="kt">implements</span> <span class="n">SomeFunctionality</span>;
<span class="n">Gizmo</span> <span class="kt">implements</span> <span class="n">MoreFunctionality</span>;
</pre>
</div>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-consequential-interfaces">consequential interfaces</dfn> of an interface <var>A</var> are:</p>
<ul>
<li data-md="">
<p>each interface <var>B</var> where the IDL states <code>A implements B</code>;</p>
<li data-md="">
<p>each interface that a consequential interface of <var>A</var> inherits from; and</p>
<li data-md="">
<p>each interface <var>D</var> where the IDL states that <code>C implements D</code>,
where <var>C</var> is a consequential interface of <var>A</var>.</p>
</ul>
<p>For a given interface, there must not
be any member defined on any of its consequential interfaces
whose identifier is the same as any other member defined on any
of those consequential interfaces or on the original interface itself.</p>
<div class="note" role="note">
<p>For example, that precludes the following:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> { <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">x</span>; };
<span class="kt">interface</span> <span class="nv">B</span> { <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">x</span>; };
<span class="n">A</span> <span class="kt">implements</span> <span class="n">B</span>; // B::x would clash with A::x
<span class="kt">interface</span> <span class="nv">C</span> { <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">y</span>; };
<span class="kt">interface</span> <span class="nv">D</span> { <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">y</span>; };
<span class="kt">interface</span> <span class="nv">E</span> : <span class="n">D</span> { };
<span class="n">C</span> <span class="kt">implements</span> <span class="n">E</span>; // D::y would clash with C::y
<span class="kt">interface</span> <span class="nv">F</span> { };
<span class="kt">interface</span> <span class="nv">H</span> { <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">z</span>; };
<span class="kt">interface</span> <span class="nv">I</span> { <span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">z</span>; };
<span class="n">F</span> <span class="kt">implements</span> <span class="n">H</span>;
<span class="n">F</span> <span class="kt">implements</span> <span class="n">I</span>; // H::z and I::z would clash when mixed in to F
</pre>
</div>
<p>No <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-20">extended attributes</a> defined in this specification are applicable to <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-6">implements statements</a>.</p>
<pre class="grammar" id="prod-ImplementsStatement">ImplementsStatement :
identifier "implements" identifier ";"
</pre>
<div class="example" id="example-4ec12a2d">
<a class="self-link" href="#example-4ec12a2d"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-29">IDL fragment</a> defines two <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-48">interfaces</a>, stating
that one interface is always implemented on objects implementing the other.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Entry</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">short</span> <span class="nv">entryType</span>;
// ...
};
<span class="kt">interface</span> <span class="nv">Observable</span> {
<span class="kt">void</span> <span class="nv">addEventListener</span>(<span class="kt">DOMString</span> <span class="nv">type</span>,
<span class="n">EventListener</span> <span class="nv">listener</span>,
<span class="kt">boolean</span> <span class="nv">useCapture</span>);
// ...
};
<span class="n">Entry</span> <span class="kt">implements</span> <span class="n">Observable</span>;
</pre>
<p>An ECMAScript implementation would thus have an “addEventListener”
property in the prototype chain of every <code class="idl">Entry</code>:</p>
<pre class="highlight"><span class="kd">var</span> e <span class="o">=</span> getEntry<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of Entry.
</span><span class="k">typeof</span> e<span class="p">.</span>addEventListener<span class="p">;</span> <span class="c1">// Evaluates to "function".
</span></pre>
<p>Note that it is not the case that all <code class="idl">Observable</code> objects implement <code class="idl">Entry</code>.</p>
</div>
<h3 class="heading settled" data-level="2.10" id="idl-objects"><span class="secno">2.10. </span><span class="content">Objects implementing interfaces</span><a class="self-link" href="#idl-objects"></a></h3>
<p>In a given implementation of a set of <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-30">IDL fragments</a>,
an object can be described as being a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-platform-object">platform object</dfn>, a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-user-object">user object</dfn>, or neither. There are two kinds of
object that are considered to be platform objects:</p>
<ul>
<li data-md="">
<p>objects that implement a non-<a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-13">callback</a> <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-49">interface</a>;</p>
<li data-md="">
<p>objects representing IDL <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-9">DOMExceptions</a></code>.</p>
</ul>
<p>In a browser, for example,
the browser-implemented DOM objects (implementing interfaces such as <code class="idl">Node</code> and <code class="idl">Document</code>) that provide access to a web page’s contents
to ECMAScript running in the page would be platform objects. These objects might be exotic objects,
implemented in a language like C++, or they might be native ECMAScript objects. Regardless,
an implementation of a given set of IDL fragments needs to be able to recognize all platform objects
that are created by the implementation. This might be done by having some internal state that records whether
a given object is indeed a platform object for that implementation, or perhaps by observing
that the object is implemented by a given internal C++ class. How exactly platform objects
are recognised by a given implementation of a set of IDL fragments is implementation specific.</p>
<p>All other objects in the system would not be treated as platform objects. For example, assume that
a web page opened in a browser loads an ECMAScript library that implements DOM Core. This library
would be considered to be a different implementation from the browser provided implementation.
The objects created by the ECMAScript library that implement the <code class="idl">Node</code> interface
will not be treated as platform objects that implement <code class="idl">Node</code> by the browser implementation.</p>
<p>User objects are those that authors would create, implementing <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-14">callback interfaces</a> that the Web APIs use to be able to invoke author-defined
operations or to send and receive values to the author’s program through
manipulating the object’s attributes. In a web page, an ECMAScript object
that implements the <code class="idl">EventListener</code> interface, which is
used to register a callback that the DOM Events implementation invokes, would be considered
to be a user object.</p>
<p>Note that user objects can only implement <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-15">callback interfaces</a> and platform objects can only implement non-callback interfaces.</p>
<h3 class="heading settled" data-level="2.11" id="idl-types"><span class="secno">2.11. </span><span class="content">Types</span><a class="self-link" href="#idl-types"></a></h3>
<p>This section lists the types supported by Web IDL, the set of values
corresponding to each type, and how <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-17">constants</a> of that type are represented.</p>
<p>The following types are known as <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-integer-type">integer types</dfn>: <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-1">byte</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-1">octet</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-1">short</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-1">unsigned short</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-1">long</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-5">unsigned long</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-2">long long</a></code> and <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-2">unsigned long long</a></code>.</p>
<p>The following types are known as <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-numeric-type">numeric types</dfn>:
the <a data-link-type="dfn" href="#dfn-integer-type" id="ref-for-dfn-integer-type-3">integer types</a>, <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-4">float</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-5">unrestricted float</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-8">double</a></code> and <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-6">unrestricted double</a></code>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-primitive-type">primitive types</dfn> are <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-6">boolean</a></code> and the <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-1">numeric types</a>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-string-type">string types</dfn> are <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-18">DOMString</a></code>, all <a data-link-type="dfn" href="#idl-enumeration" id="ref-for-idl-enumeration-1">enumeration types</a>, <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-3">ByteString</a></code> and <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-4">USVString</a></code>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-exception-type">exception types</dfn> are <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-3">Error</a></code> and <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-10">DOMException</a></code>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-typed-array-type">typed array types</dfn> are <code class="idl"><a data-link-type="idl" href="#idl-Int8Array" id="ref-for-idl-Int8Array-1">Int8Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Int16Array" id="ref-for-idl-Int16Array-1">Int16Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Int32Array" id="ref-for-idl-Int32Array-1">Int32Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint8Array" id="ref-for-idl-Uint8Array-1">Uint8Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint16Array" id="ref-for-idl-Uint16Array-1">Uint16Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint32Array" id="ref-for-idl-Uint32Array-1">Uint32Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint8ClampedArray" id="ref-for-idl-Uint8ClampedArray-1">Uint8ClampedArray</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Float32Array" id="ref-for-idl-Float32Array-1">Float32Array</a></code> and <code class="idl"><a data-link-type="idl" href="#idl-Float64Array" id="ref-for-idl-Float64Array-1">Float64Array</a></code>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-buffer-source-type">buffer source types</dfn> are <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-1">ArrayBuffer</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-DataView" id="ref-for-idl-DataView-1">DataView</a></code>,
and the <a data-link-type="dfn" href="#dfn-typed-array-type" id="ref-for-dfn-typed-array-type-1">typed array types</a>.</p>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-1">object</a></code> type,
all <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-2">interface types</a> and the <a data-link-type="dfn" href="#dfn-exception-type" id="ref-for-dfn-exception-type-1">exception types</a> are known as <dfn data-dfn-type="dfn" data-export="" id="dfn-object-type">object types<a class="self-link" href="#dfn-object-type"></a></dfn>.</p>
<p>Every type has a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-type-name">type name</dfn>, which
is a string, not necessarily unique, that identifies the type.
Each sub-section below defines what the type name is for each
type.</p>
<p id="type-conversion-exceptions"> When conversions are made from language binding specific types to
IDL types in order to invoke an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-27">operation</a> or assign a value to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-20">attribute</a>,
all conversions necessary will be performed before the
specified functionality of the operation or attribute assignment
is carried out. If the conversion cannot
be performed, then the operation will not run or
the attribute will not be updated. In some language bindings,
type conversions could result in an exception being thrown.
In such cases, these exceptions will be propagated to the
code that made the attempt to invoke the operation or
assign to the attribute. </p>
<pre class="grammar" id="prod-Type">Type :
SingleType
UnionType Null
</pre>
<pre class="grammar" id="prod-SingleType">SingleType :
NonAnyType
"any"
</pre>
<pre class="grammar" id="prod-UnionType">UnionType :
"(" UnionMemberType "or" UnionMemberType UnionMemberTypes ")"
</pre>
<pre class="grammar" id="prod-UnionMemberType">UnionMemberType :
NonAnyType
UnionType Null
</pre>
<pre class="grammar" id="prod-UnionMemberTypes">UnionMemberTypes :
"or" UnionMemberType UnionMemberTypes
ε
</pre>
<pre class="grammar" id="prod-NonAnyType">NonAnyType :
PrimitiveType Null
PromiseType Null
"ByteString" Null
"DOMString" Null
"USVString" Null
identifier Null
"sequence" "<" Type ">" Null
"object" Null
"RegExp" Null
"Error" Null
"DOMException" Null
BufferRelatedType Null
"FrozenArray" "<" Type ">" Null
OpenDictionaryType Null
</pre>
<div data-fill-with="grammar-ConstType"></div>
<pre class="grammar" id="prod-PrimitiveType">PrimitiveType :
UnsignedIntegerType
UnrestrictedFloatType
"boolean"
"byte"
"octet"
</pre>
<pre class="grammar" id="prod-UnrestrictedFloatType">UnrestrictedFloatType :
"unrestricted" FloatType
FloatType
</pre>
<pre class="grammar" id="prod-FloatType">FloatType :
"float"
"double"
</pre>
<pre class="grammar" id="prod-UnsignedIntegerType">UnsignedIntegerType :
"unsigned" IntegerType
IntegerType
</pre>
<pre class="grammar" id="prod-IntegerType">IntegerType :
"short"
"long" OptionalLong
</pre>
<pre class="grammar" id="prod-OptionalLong">OptionalLong :
"long"
ε
</pre>
<pre class="grammar" id="prod-PromiseType">PromiseType :
"Promise" "<" ReturnType ">"
</pre>
<pre class="grammar" id="prod-OpenDictionaryType">OpenDictionaryType :
"OpenDictionary" "<" Type OpenDictionaryTypeMaybeValue
</pre>
<pre class="grammar" id="prod-OpenDictionaryTypeMaybeValue">OpenDictionaryTypeMaybeValue :
">"
"," Type ">"
</pre>
<pre class="grammar" id="prod-Null">Null :
"?"
ε
</pre>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.1" data-lt="any" id="idl-any"><span class="secno">2.11.1. </span><span class="content">any</span><span id="dom-any"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-1">any</a></code> type is the union of all other possible
non-<a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-7">union</a> types.
Its <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-1">type name</a> is “Any”.</p>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-2">any</a></code> type is like
a discriminated union type, in that each of its values has a
specific non-<code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-3">any</a></code> type
associated with it. For example, one value of the <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-4">any</a></code> type is the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-6">unsigned long</a></code> 150, while another is the <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-2">long</a></code> 150.
These are distinct values.</p>
<p>The particular type of an <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-5">any</a></code> value is known as its <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-specific-type">specific type</dfn>.
(Values of <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-8">union types</a> also have <a data-link-type="dfn" href="#dfn-specific-type" id="ref-for-dfn-specific-type-2">specific types</a>.)</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.2" data-lt="boolean" id="idl-boolean"><span class="secno">2.11.2. </span><span class="content">boolean</span><span id="dom-boolean"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-7">boolean</a></code> type has two values: <emu-val>true</emu-val> and <emu-val>false</emu-val>.</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-8">boolean</a></code> constant values in IDL are
represented with the <code>true</code> and <code>false</code> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-2">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-9">boolean</a></code> type is “Boolean”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.3" data-lt="byte" id="idl-byte"><span class="secno">2.11.3. </span><span class="content">byte</span><span id="dom-byte"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-2">byte</a></code> type is a signed integer
type that has values in the range [−128, 127].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-3">byte</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-3">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-4">byte</a></code> type is “Byte”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.4" data-lt="octet" id="idl-octet"><span class="secno">2.11.4. </span><span class="content">octet</span><span id="dom-octet"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-2">octet</a></code> type is an unsigned integer
type that has values in the range [0, 255].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-3">octet</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-4">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-4">octet</a></code> type is “Octet”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.5" data-lt="short" id="idl-short"><span class="secno">2.11.5. </span><span class="content">short</span><span id="dom-short"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-2">short</a></code> type is a signed integer
type that has values in the range [−32768, 32767].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-3">short</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-5">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-4">short</a></code> type is “Short”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.6" data-lt="unsigned short" id="idl-unsigned-short"><span class="secno">2.11.6. </span><span class="content">unsigned short</span><span id="dom-unsignedshort"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-2">unsigned short</a></code> type is an unsigned integer
type that has values in the range [0, 65535].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-3">unsigned short</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-6">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-4">unsigned short</a></code> type is “UnsignedShort”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.7" data-lt="long" id="idl-long"><span class="secno">2.11.7. </span><span class="content">long</span><span id="dom-long"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-3">long</a></code> type is a signed integer
type that has values in the range [−2147483648, 2147483647].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-4">long</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-7">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-5">long</a></code> type is “Long”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.8" data-lt="unsigned long" id="idl-unsigned-long"><span class="secno">2.11.8. </span><span class="content">unsigned long</span><span id="dom-unsignedlong"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-7">unsigned long</a></code> type is an unsigned integer
type that has values in the range [0, 4294967295].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-8">unsigned long</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-8">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-9">unsigned long</a></code> type is “UnsignedLong”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.9" data-lt="long long" id="idl-long-long"><span class="secno">2.11.9. </span><span class="content">long long</span><span id="dom-longlong"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-3">long long</a></code> type is a signed integer
type that has values in the range [−9223372036854775808, 9223372036854775807].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-4">long long</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-9">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-5">long long</a></code> type is “LongLong”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.10" data-lt="unsigned long long" id="idl-unsigned-long-long"><span class="secno">2.11.10. </span><span class="content">unsigned long long</span><span id="dom-unsignedlonglong"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-3">unsigned long long</a></code> type is an unsigned integer
type that has values in the range [0, 18446744073709551615].</p>
<p><code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-4">unsigned long long</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-integer">integer</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-10">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-5">unsigned long long</a></code> type is “UnsignedLongLong”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.11" data-lt="float" id="idl-float"><span class="secno">2.11.11. </span><span class="content">float</span><span id="dom-float"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-5">float</a></code> type is a floating point numeric
type that corresponds to the set of finite single-precision 32 bit
IEEE 754 floating point numbers. <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a></p>
<p><code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-6">float</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-11">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-7">float</a></code> type is “Float”.</p>
<p class="advisement"> Unless there are specific reasons to use a 32 bit floating point type,
specifications should use <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-9">double</a></code> rather than <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-8">float</a></code>,
since the set of values that a <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-10">double</a></code> can
represent more closely matches an ECMAScript <emu-val>Number</emu-val>. </p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.12" data-lt="unrestricted float" id="idl-unrestricted-float"><span class="secno">2.11.12. </span><span class="content">unrestricted float</span><span id="dom-unrestrictedfloat"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-6">unrestricted float</a></code> type is a floating point numeric
type that corresponds to the set of all possible single-precision 32 bit
IEEE 754 floating point numbers, finite and non-finite. <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a></p>
<p><code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-7">unrestricted float</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-12">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-8">unrestricted float</a></code> type is “UnrestrictedFloat”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.13" data-lt="double" id="idl-double"><span class="secno">2.11.13. </span><span class="content">double</span><span id="dom-double"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-11">double</a></code> type is a floating point numeric
type that corresponds to the set of finite double-precision 64 bit
IEEE 754 floating point numbers. <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a></p>
<p><code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-12">double</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-13">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-13">double</a></code> type is “Double”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.14" data-lt="unrestricted double" id="idl-unrestricted-double"><span class="secno">2.11.14. </span><span class="content">unrestricted double</span><span id="dom-unrestricteddouble"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-7">unrestricted double</a></code> type is a floating point numeric
type that corresponds to the set of all possible double-precision 64 bit
IEEE 754 floating point numbers, finite and non-finite. <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a></p>
<p><code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-8">unrestricted double</a></code> constant values in IDL are
represented with <emu-t class="symbol"><a href="#prod-float">float</a></emu-t> tokens.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-14">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-9">unrestricted double</a></code> type is “UnrestrictedDouble”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.15" data-lt="DOMString" id="idl-DOMString"><span class="secno">2.11.15. </span><span class="content">DOMString</span><span id="dom-DOMString"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-19">DOMString</a></code> type corresponds to
the set of all possible sequences of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-1">code units</a>.
Such sequences are commonly interpreted as UTF-16 encoded strings <a data-link-type="biblio" href="#biblio-rfc2781">[RFC2781]</a> although this is not required.
While <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-20">DOMString</a></code> is defined to be
an OMG IDL boxed <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-6">sequence</a><<code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-5">unsigned short</a></code>> valuetype
in <a href="https://www.w3.org/TR/DOM-Level-3-Core//core#ID-C74D1578">DOM Level 3 Core §The DOMString Type</a>,
this document defines <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-21">DOMString</a></code> to be an intrinsic type
so as to avoidspecial casing that sequence type
in various situations where a string is required.</p>
<p class="note" role="note">Note: Note also that <emu-val>null</emu-val> is not a value of type <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-22">DOMString</a></code>.
To allow <emu-val>null</emu-val>, a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-9">nullable</a> <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-23">DOMString</a></code>,
written as <code>DOMString?</code> in IDL, needs to be used.</p>
<p>Nothing in this specification requires a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-24">DOMString</a></code> value to be a valid UTF-16 string. For example, a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-25">DOMString</a></code> value might include unmatched surrogate pair characters. However, authors
of specifications using Web IDL might want to obtain a sequence of <a data-link-type="dfn" href="http://www.unicode.org/glossary/#unicode_scalar_value">Unicode scalar values</a> given a particular sequence of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-2">code units</a>.
The following algorithm defines a way to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="obtain Unicode|convert to a sequence of Unicode scalar values" id="dfn-obtain-unicode">convert a DOMString to a sequence of Unicode scalar values</dfn>:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-26">DOMString</a></code> value.</p>
<li data-md="">
<p>Let <var>n</var> be the length of <var>S</var>.</p>
<li data-md="">
<p>Initialize <var>i</var> to 0.</p>
<li data-md="">
<p>Initialize <var>U</var> to be an empty sequence of Unicode characters.</p>
<li data-md="">
<p>While <var>i</var> < <var>n</var>:</p>
<ol>
<li data-md="">
<p>Let <var>c</var> be the <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-3">code unit</a> in <var>S</var> at index <var>i</var>.</p>
<li data-md="">
<p>Depending on the value of <var>c</var>:</p>
<dl class="switch">
<dt data-md="">
<p><var>c</var> < 0xD800 or <var>c</var> > 0xDFFF</p>
<dd data-md="">
<p>Append to <var>U</var> the Unicode character with code point <var>c</var>.</p>
<dt data-md="">
<p>0xDC00 ≤ <var>c</var> ≤ 0xDFFF</p>
<dd data-md="">
<p>Append to <var>U</var> a <span class="char">U+FFFD REPLACEMENT CHARACTER</span>.</p>
<dt data-md="">
<p>0xD800 ≤ <var>c</var> ≤ 0xDBFF</p>
<dd data-md="">
<ol class="only">
<li data-md="">
<p>If <var>i</var> = <var>n</var>−1, then append to <var>U</var> a <span class="char">U+FFFD REPLACEMENT CHARACTER</span>.</p>
<li data-md="">
<p>Otherwise, <var>i</var> < <var>n</var>−1:</p>
<ol>
<li data-md="">
<p>Let <var>d</var> be the code unit in <var>S</var> at index <var>i</var>+1.</p>
<li data-md="">
<p>If 0xDC00 ≤ <var>d</var> ≤ 0xDFFF, then:</p>
<ol>
<li data-md="">
<p>Let <var>a</var> be <var>c</var> & 0x3FF.</p>
<li data-md="">
<p>Let <var>b</var> be <var>d</var> & 0x3FF.</p>
<li data-md="">
<p>Append to <var>U</var> the Unicode character with
code point 2<sup>16</sup>+2<sup>10</sup><var>a</var>+<var>b</var>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var>+1.</p>
</ol>
<li data-md="">
<p>Otherwise, <var>d</var> < 0xDC00 or <var>d</var> > 0xDFFF.
Append to <var>U</var> a <span class="char">U+FFFD REPLACEMENT CHARACTER</span>.</p>
</ol>
</ol>
</dl>
<li data-md="">
<p>Set <var>i</var> to <var>i</var>+1.</p>
</ol>
<li data-md="">
<p>Return <var>U</var>.</p>
</ol>
<p>There is no way to represent a constant <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-27">DOMString</a></code> value in IDL, although <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-28">DOMString</a></code> <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-9">dictionary member</a> and <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-8">operation optional argument</a> default values
can be specified using a <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> literal.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-15">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-29">DOMString</a></code> type is “String”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.16" data-lt="ByteString" id="idl-ByteString"><span class="secno">2.11.16. </span><span class="content">ByteString</span><span id="dom-ByteString"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-4">ByteString</a></code> type
corresponds to the set of all possible sequences of bytes.
Such sequences might be interpreted as UTF-8 encoded strings <a data-link-type="biblio" href="#biblio-rfc3629">[RFC3629]</a> or strings in some other 8-bit-per-code-unit encoding, although this is not required.</p>
<p>There is no way to represent a constant <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-5">ByteString</a></code> value in IDL, although <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-6">ByteString</a></code> <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-10">dictionary member</a> and <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-9">operation optional argument</a> default values
can be specified using a <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> literal.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-16">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-7">ByteString</a></code> type is “ByteString”.</p>
<p class="advisement"> Specifications should only use <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-8">ByteString</a></code> for interfacing with protocols
that use bytes and strings interchangably, such as HTTP. In general,
strings should be represented with <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-30">DOMString</a></code> values, even if it is expected
that values of the string will always be in ASCII or some
8 bit character encoding. <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-7">Sequences</a>, <a data-link-type="dfn" href="#dfn-frozen-array-type" id="ref-for-dfn-frozen-array-type-2">frozen arrays</a> or <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-typedarray-objects">Typed Arrays</a> with <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-5">octet</a></code> or <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-5">byte</a></code> elements should be used for holding
8 bit data rather than <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-9">ByteString</a></code>. </p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.17" data-lt="USVString" id="idl-USVString"><span class="secno">2.11.17. </span><span class="content">USVString</span><span id="dom-USVString"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-5">USVString</a></code> type
corresponds to the set of all possible sequences of <a data-link-type="dfn" href="http://www.unicode.org/glossary/#unicode_scalar_value">Unicode scalar values</a>,
which are all of the Unicode code points apart from the
surrogate code points.</p>
<p>There is no way to represent a constant <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-6">USVString</a></code> value in IDL, although <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-7">USVString</a></code> <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-11">dictionary member</a> and <a data-link-type="dfn" href="#dfn-optional-argument" id="ref-for-dfn-optional-argument-10">operation optional argument</a> default values
can be specified using a <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> literal.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-17">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-8">USVString</a></code> type is “USVString”.</p>
<p class="advisement"> Specifications should only use <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-9">USVString</a></code> for APIs that perform
text processing and need a string of Unicode
scalar values to operate on. Most APIs that use strings
should instead be using <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-31">DOMString</a></code>,
which does not make any interpretations of the <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-4">code units</a> in the string. When in doubt, use <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-32">DOMString</a></code>. </p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.18" data-lt="object" id="idl-object"><span class="secno">2.11.18. </span><span class="content">object</span><span id="dom-object"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-2">object</a></code> type corresponds to the set of
all possible non-null object references.</p>
<p>There is no way to represent a constant <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-3">object</a></code> value in IDL.</p>
<p>To denote a type that includes all possible object references plus the <emu-val>null</emu-val> value, use the <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-10">nullable type</a> <code class="idl">object?</code>.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-18">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-4">object</a></code> type is “Object”.</p>
<h4 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="2.11.19" data-lt="Interface types" data-noexport="" id="idl-interface"><span class="secno">2.11.19. </span><span class="content">Interface types</span></h4>
<p>An <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-41">identifier</a> that
identifies an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-50">interface</a> is used to refer to
a type that corresponds to the set of all possible non-null references to objects that
implement that interface.</p>
<p>For non-callback interfaces, an IDL value of the interface type is represented just
by an object reference. For <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-16">callback interfaces</a>, an IDL value of the interface type
is represented by a tuple of an object reference and a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-callback-context">callback context</dfn>.
The <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-1">callback context</a> is a language
binding specific value, and is used to store information about the execution context at
the time the language binding specific object reference is converted to an IDL value.</p>
<p class="note" role="note">Note: For ECMAScript objects, the <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-2">callback context</a> is used to hold a reference to the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#incumbent-settings-object">incumbent settings object</a> at the time the <emu-val>Object</emu-val> value
is converted to an IDL callback interface type value. See <a href="#es-interface">§3.2.20 Interface types</a>.</p>
<p>There is no way to represent a constant object reference value for
a particular interface type in IDL.</p>
<p>To denote a type that includes all possible references to objects implementing
the given interface plus the <emu-val>null</emu-val> value,
use a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-11">nullable type</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-19">type name</a> of an interface type
is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-42">identifier</a> of the interface.</p>
<h4 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="2.11.20" data-lt="Dictionary types" data-noexport="" id="idl-dictionary"><span class="secno">2.11.20. </span><span class="content">Dictionary types</span></h4>
<p>An <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-43">identifier</a> that
identifies a <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-10">dictionary</a> is used to refer to
a type that corresponds to the set of all dictionaries that adhere to
the dictionary definition.</p>
<p>There is no way to represent a constant dictionary value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-20">type name</a> of a dictionary type
is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-44">identifier</a> of the dictionary.</p>
<h4 class="heading settled dfn-paneled" data-dfn-type="dfn" data-export="" data-level="2.11.21" data-lt="Enumeration types" id="idl-enumeration"><span class="secno">2.11.21. </span><span class="content">Enumeration types</span></h4>
<p>An <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-45">identifier</a> that
identifies an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-15">enumeration</a> is used to
refer to a type whose values are the set of strings (sequences of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-5">code units</a>, as with <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-33">DOMString</a></code>) that are the <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-4">enumeration’s values</a>.</p>
<p>Like <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-34">DOMString</a></code>, there is no way to represent a constant <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-16">enumeration</a> value in IDL, although enumeration-typed <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-12">dictionary member</a> <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-7">default values</a> can be specified using a <emu-t class="symbol"><a href="#prod-string">string</a></emu-t> literal.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-21">type name</a> of an enumeration type
is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-46">identifier</a> of the enumeration.</p>
<h4 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="2.11.22" data-lt="Callback function types" data-noexport="" id="idl-callback-function"><span class="secno">2.11.22. </span><span class="content">Callback function types</span></h4>
<p>An <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-47">identifier</a> that identifies
a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-17">callback function</a> is used to refer to
a type whose values are references to objects that are functions with the given signature.</p>
<p>An IDL value of the callback function type is represented by a tuple of an object
reference and a <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-3">callback context</a>.</p>
<p class="note" role="note">Note: As with <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-3">callback interface types</a>, the <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-4">callback context</a> is used to hold a
reference to the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#incumbent-settings-object">incumbent settings object</a> at
the time an ECMAScript <emu-val>Object</emu-val> value is converted to an IDL
callback function type value. See <a href="#es-callback-function">§3.2.23 Callback function types</a>.</p>
<p>There is no way to represent a constant <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-18">callback function</a> value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-22">type name</a> of a callback function type
is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-48">identifier</a> of the callback function.</p>
<h4 class="heading settled" data-level="2.11.23" id="idl-nullable-type"><span class="secno">2.11.23. </span><span class="content">Nullable types — <var>T</var>?</span><a class="self-link" href="#idl-nullable-type"></a></h4>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-nullable-type">nullable type</dfn> is an IDL type constructed
from an existing type (called the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-inner-type">inner type</dfn>),
which just allows the additional value <emu-val>null</emu-val> to be a member of its set of values. <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-12">Nullable types</a> are represented in IDL by placing a <span class="char">U+003F QUESTION MARK ("?")</span> character after an existing type. The inner type must not
be <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-6">any</a></code>,
another nullable type, or a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-9">union type</a> that itself has <a data-link-type="dfn" href="#dfn-includes-a-nullable-type" id="ref-for-dfn-includes-a-nullable-type-2">includes a nullable type</a> or has a dictionary type as one of its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-4">flattened member types</a>.</p>
<p class="note" role="note">Note: Although dictionary types can in general be nullable, they cannot when used
as the type of an operation argument or a dictionary member.</p>
<p>Nullable type constant values in IDL are represented in the same way that
constant values of their <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-5">inner type</a> would be represented, or with the <code>null</code> token.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-23">type name</a> of a nullable type
is the concatenation of the type name of the inner type <var>T</var> and
the string “OrNull”.</p>
<div class="example" id="example-e4a56b3a">
<a class="self-link" href="#example-e4a56b3a"></a>
<p>For example, a type that allows the values <emu-val>true</emu-val>, <emu-val>false</emu-val> and <emu-val>null</emu-val> is written as <code class="idl">boolean?</code>:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">MyConstants</span> {
<span class="kt">const</span> <span class="kt">boolean</span>? <span class="nv">ARE_WE_THERE_YET</span> = <span class="kt">false</span>;
};
</pre>
<p>The following <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-51">interface</a> has two <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-21">attributes</a>: one whose value can
be a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-35">DOMString</a></code> or the <emu-val>null</emu-val> value, and another whose value can be a reference to a <code class="idl">Node</code> object or the <emu-val>null</emu-val> value:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Node</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span>? <span class="nv">namespaceURI</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Node</span>? <span class="nv">parentNode</span>;
// ...
};
</pre>
</div>
<h4 class="heading settled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.24" data-lt="sequence|sequence<T>" id="idl-sequence"><span class="secno">2.11.24. </span><span class="content">Sequence types — sequence<<var>T</var>></span><span id="dom-sequence"></span><a class="self-link" href="#idl-sequence"></a></h4>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-lt="sequence type" data-noexport="" expose="" id="sequence-type">sequence<<var>T</var>></dfn> type is a parameterized type whose values are (possibly zero-length) sequences of
values of type <var>T</var>.</p>
<p>Sequences are always passed by value. In
language bindings where a sequence is represented by an object of
some kind, passing a sequence to a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-7">platform object</a> will not result in a reference to the sequence being kept by that object.
Similarly, any sequence returned from a platform object
will be a copy and modifications made to it will not be visible to the platform object.</p>
<p>There is no way to represent a constant sequence value in IDL.</p>
<p>Sequences must not be used as the
type of an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-22">attribute</a> or <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-18">constant</a>.</p>
<p class="note" role="note">Note: This restriction exists so that it is clear to specification writers
and API users that <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-8">sequences</a> are copied rather than having references
to them passed around. Instead of a writable <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-23">attribute</a> of a sequence
type, it is suggested that a pair of <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-28">operations</a> to get and set the
sequence is used.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-24">type name</a> of a sequence type
is the concatenation of the type name for <var>T</var> and
the string “Sequence”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="dictionary" data-export="" data-level="2.11.25" data-lt="OpenDictionary" id="idl-open-dictionary"><span class="secno">2.11.25. </span><span class="content">Open dictionary types — OpenDictionary<[<var>K</var>,] <var>V</var>></span></h4>
<p>An <dfn data-dfn-type="dfn" data-export="" id="open-dictionary-type">open dictionary type<a class="self-link" href="#open-dictionary-type"></a></dfn> is a parameterized <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-4">dictionary type</a> whose values are ordered associative arrays mapping instances of <var>K</var> to
instances of <var>V</var>. The (key, value) pairs are called <dfn class="dfn-paneled" data-dfn-for="OpenDictionary" data-dfn-type="dfn" data-noexport="" id="opendictionary-mappings">mappings</dfn>.
The order of an open dictionary’s mappings is determined when the open
dictionary value is created.</p>
<p><var>K</var> must be one of <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-36">DOMString</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-10">USVString</a></code>, or <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-10">ByteString</a></code>. In a type
name of the form <code>OpenDictionary<<var>V</var>></code>, which omits <var>K</var>, <var>K</var> defaults
to <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-37">DOMString</a></code>.</p>
<p>Open dictionaries are always passed by value. In language bindings where an open
dictionary is represented by an object of some kind, passing an open dictionary
to a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-8">platform object</a> will not result in a reference to the open dictionary
being kept by that object. Similarly, any open dictionary returned from a
platform object will be a copy and modifications made to it will not be visible
to the platform object.</p>
<p>There is no way to represent a constant open dictionary value in IDL.</p>
<p>Open dictionaries must not be used as the type of an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-24">attribute</a> or <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-19">constant</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-25">type name</a> of an open dictionary type is the concatenation of the type
name for <var>K</var>, the type name for <var>V</var> and the string “OpenDictionary”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.26" data-lt="Promise|Promise<T>" id="idl-promise"><span class="secno">2.11.26. </span><span class="content">Promise types — Promise<<var>T</var>></span><span id="dom-promise"></span></h4>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-promise-type">promise type</dfn> is a parameterized type
whose values are references to objects that “is used as a place holder
for the eventual results of a deferred (and possibly asynchronous) computation
result of an asynchronous operation”.
See <a href="https://tc39.github.io/ecma262/#sec-promise-objects">section 25.4</a> of the ECMAScript specification for details on the semantics of promise objects.</p>
<p>There is no way to represent a promise value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-26">type name</a> of a promise type
is the concatenation of the type name for <var>T</var> and
the string “Promise”.</p>
<h4 class="heading settled" data-level="2.11.27" id="idl-union"><span class="secno">2.11.27. </span><span class="content">Union types</span><a class="self-link" href="#idl-union"></a></h4>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-union-type">union type</dfn> is a type whose set of values
is the union of those in two or more other types. Union types (matching <emu-nt><a href="#prod-UnionType">UnionType</a></emu-nt>)
are written as a series of types separated by the <code>or</code> keyword
with a set of surrounding parentheses.
The types which comprise the union type are known as the
union’s <dfn class="dfn-paneled" data-dfn-for="union" data-dfn-type="dfn" data-export="" id="dfn-union-member-type">member types</dfn>.</p>
<div class="note" role="note">
<p>For example, you might write <code>(Node or DOMString)</code> or <code>(double or sequence<double>)</code>. When applying a <code>?</code> suffix to a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-10">union type</a> as a whole, it is placed after the closing parenthesis,
as in <code>(Node or DOMString)?</code>.</p>
<p>Note that the <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-4">member types</a> of a union type do not descend into nested union types. So for <code>(double or (sequence<long> or Event) or (Node or DOMString)?)</code> the member types
are <code>double</code>, <code>(sequence<long> or Event)</code> and <code>(Node or DOMString)?</code>.</p>
</div>
<p>Like the <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-7">any</a></code> type, values of
union types have a <a data-link-type="dfn" href="#dfn-specific-type" id="ref-for-dfn-specific-type-3">specific type</a>,
which is the particular <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-5">member type</a> that matches the value.</p>
<p>The <dfn class="dfn-paneled" data-dfn-for="union" data-dfn-type="dfn" data-export="" id="dfn-flattened-union-member-types">flattened member types</dfn> of a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-11">union type</a> is a set of types
determined as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>T</var> be the <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-12">union type</a>.</p>
<li data-md="">
<p>Initialize <var>S</var> to ∅.</p>
<li data-md="">
<p>For each <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-6">member type</a> <var>U</var> of <var>T</var>:</p>
<ol>
<li data-md="">
<p>If <var>U</var> is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-13">nullable type</a>, then
set <var>U</var> to be the <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-6">inner type</a> of <var>U</var>.</p>
<li data-md="">
<p>If <var>U</var> is a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-13">union type</a>, then
add to <var>S</var> the <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-5">flattened member types</a> of <var>U</var>.</p>
<li data-md="">
<p>Otherwise, <var>U</var> is not a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-14">union type</a>.
Add <var>U</var> to <var>S</var>.</p>
</ol>
<li data-md="">
<p>Return <var>S</var>.</p>
</ol>
<p class="note" role="note">Note: For example, the <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-6">flattened member types</a> of the <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-15">union type</a> <code>(Node or (sequence<long> or Event) or (XMLHttpRequest or DOMString)? or sequence<(sequence<double> or NodeList)>)</code> are the six types <code>Node</code>, <code>sequence<long></code>, <code>Event</code>, <code>XMLHttpRequest</code>, <code>DOMString</code> and <code>sequence<(sequence<double> or NodeList)></code>.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-number-of-nullable-member-types">number of nullable member types</dfn> of a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-16">union type</a> is an integer
determined as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>T</var> be the <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-17">union type</a>.</p>
<li data-md="">
<p>Initialize <var>n</var> to 0.</p>
<li data-md="">
<p>For each <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-7">member type</a> <var>U</var> of <var>T</var>:</p>
<ol>
<li data-md="">
<p>If <var>U</var> is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-14">nullable type</a>, then:</p>
<ol>
<li data-md="">
<p>Set <var>n</var> to <var>n</var> + 1.</p>
<li data-md="">
<p>Set <var>U</var> to be the <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-7">inner type</a> of <var>U</var>.</p>
</ol>
<li data-md="">
<p>If <var>U</var> is a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-18">union type</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>m</var> be the <a data-link-type="dfn" href="#dfn-number-of-nullable-member-types" id="ref-for-dfn-number-of-nullable-member-types-1">number of nullable member types</a> of <var>U</var>.</p>
<li data-md="">
<p>Set <var>n</var> to <var>n</var> + <var>m</var>.</p>
</ol>
</ol>
<li data-md="">
<p>Return <var>n</var>.</p>
</ol>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-8">any</a></code> type must not
be used as a <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-8">union member type</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-number-of-nullable-member-types" id="ref-for-dfn-number-of-nullable-member-types-2">number of nullable member types</a> of a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-19">union type</a> must
be 0 or 1, and if it is 1 then the union type must also not have
a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-5">dictionary type</a> in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-7">flattened member types</a>.</p>
<p>A type <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-includes-a-nullable-type">includes a nullable type</dfn> if:</p>
<ul>
<li data-md="">
<p>the type is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-15">nullable type</a>, or</p>
<li data-md="">
<p>the type is a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-20">union type</a> and its <a data-link-type="dfn" href="#dfn-number-of-nullable-member-types" id="ref-for-dfn-number-of-nullable-member-types-3">number of nullable member types</a> is 1.</p>
</ul>
<p>Each pair of <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-8">flattened member types</a> in a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-21">union type</a>, <var>T</var> and <var>U</var>,
must be <a data-link-type="dfn" href="#dfn-distinguishable" id="ref-for-dfn-distinguishable-4">distinguishable</a>.</p>
<p><a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-22">Union type</a> constant values
in IDL are represented in the same way that constant values of their <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-9">member types</a> would be
represented.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-27">type name</a> of a union
type is formed by taking the type names of each member type, in order,
and joining them with the string “Or”.</p>
<div data-fill-with="grammar-UnionType"></div>
<div data-fill-with="grammar-UnionMemberType"></div>
<div data-fill-with="grammar-UnionMemberTypes"></div>
<div data-fill-with="grammar-NonAnyType"></div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.28" data-lt="RegExp" id="idl-RegExp"><span class="secno">2.11.28. </span><span class="content">RegExp</span><span id="dom-RegExp"></span></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-1">RegExp</a></code> type is a type
whose values are references to objects that represent regular expressions.
The particular regular expression language and the features it supports
is language binding specific.</p>
<p>There is no way to represent a constant <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-2">RegExp</a></code> value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-28">type name</a> of the <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-3">RegExp</a></code> type is “RegExp”.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.29" data-lt="Error" id="idl-Error"><span class="secno">2.11.29. </span><span class="content">Error</span><span id="dom-Error"></span></h4>
<p>The <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-4">Error</a></code> type corresponds to the
set of all possible non-null references to exception objects, including <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-4">simple exceptions</a> and <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-11">DOMExceptions</a></code>.</p>
<p>There is no way to represent a constant <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-5">Error</a></code> value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-29">type name</a> of the <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-6">Error</a></code> type is “Error”.</p>
<h4 class="heading settled" data-level="2.11.30" id="idl-DOMException"><span class="secno">2.11.30. </span><span class="content">DOMException</span><a class="self-link" href="#idl-DOMException"></a></h4>
<p>The <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-12">DOMException</a></code> type corresponds to the
set of all possible non-null references to objects
representing <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-13">DOMExceptions</a></code>.</p>
<p>There is no way to represent a constant <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-14">DOMException</a></code> value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-30">type name</a> of the <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-15">DOMException</a></code> type is “DOMException”.</p>
<h4 class="heading settled" data-level="2.11.31" id="idl-buffer-source-types"><span class="secno">2.11.31. </span><span class="content">Buffer source types</span><a class="self-link" href="#idl-buffer-source-types"></a></h4>
<p>There are a number of types that correspond to sets of all possible non-null
references to objects that represent a buffer of data or a view on to a buffer of
data. The table below lists these types and the kind of buffer or view they represent.</p>
<table class="vert data">
<tbody>
<tr>
<th>Type
<th>Kind of buffer
<tr>
<td><dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-ArrayBuffer">ArrayBuffer</dfn>
<td>An object that holds a pointer (which may be null) to a buffer of a fixed number of bytes
<tr>
<td><dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-DataView">DataView</dfn>
<td>A view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-2">ArrayBuffer</a></code> that allows typed access to integers and floating point values stored at arbitrary offsets into the buffer
<tr>
<td> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Int8Array">Int8Array</dfn>,<br> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Int16Array">Int16Array</dfn>,<br> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Int32Array">Int32Array</dfn>
<td>A view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-3">ArrayBuffer</a></code> that exposes it as an array of two’s complement signed integers of the given size in bits
<tr>
<td> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Uint8Array">Uint8Array</dfn>,<br> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Uint16Array">Uint16Array</dfn>,<br> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Uint32Array">Uint32Array</dfn>
<td>A view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-4">ArrayBuffer</a></code> that exposes it as an array of unsigned integers of the given size in bits
<tr>
<td><dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Uint8ClampedArray">Uint8ClampedArray</dfn>
<td>A view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-5">ArrayBuffer</a></code> that exposes it as an array of unsigned 8 bit integers with clamped conversions
<tr>
<td> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Float32Array">Float32Array</dfn>,<br> <dfn class="dfn-paneled idl-code" data-dfn-type="interface" data-export="" id="idl-Float64Array">Float64Array</dfn>
<td>A view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-6">ArrayBuffer</a></code> that exposes it as an array of IEEE 754 floating point numbers of the given size in bits
</table>
<p class="note" role="note">Note: These types all correspond to classes defined in ECMAScript.</p>
<p>To <dfn class="dfn-paneled" data-dfn-for="ArrayBuffer" data-dfn-type="dfn" data-export="" id="dfn-detach">detach</dfn> an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-7">ArrayBuffer</a></code> is to set its buffer pointer to <emu-val>null</emu-val>.</p>
<p>There is no way to represent a constant value of any of these types in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-31">type name</a> of all
of these types is the name of the type itself.</p>
<p>At the specification prose level, IDL <a data-link-type="dfn" href="#dfn-buffer-source-type" id="ref-for-dfn-buffer-source-type-1">buffer source types</a> are simply references to objects. To inspect or manipulate the bytes inside the buffer,
specification prose must first either <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="get a reference to the buffer source" id="dfn-get-buffer-source-reference">get a reference to the bytes held by the buffer source</dfn> or <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="get a copy of the buffer source" id="dfn-get-buffer-source-copy">get a copy of the bytes held by the buffer source</dfn>.
With a reference to the buffer source’s bytes, specification prose can get or set individual
byte values using that reference.</p>
<div class="advisement">
<p>Extreme care must be taken when writing specification text that gets a reference
to the bytes held by a buffer source, as the underyling data can easily be changed
by the script author or other APIs at unpredictable times. If you are using a buffer source type
as an operation argument to obtain a chunk of binary data that will not be modified,
it is strongly recommended to get a copy of the buffer source’s bytes at the beginning
of the prose defining the operation.</p>
<p>Requiring prose to explicitly get a reference to or copy of the bytes is intended to
help specification reviewers look for problematic uses of these buffer source types.</p>
</div>
<div class="note" role="note">
<p>When designing APIs that take a buffer, it is recommended to use the <code class="idl"><a data-link-type="idl" href="#BufferSource" id="ref-for-BufferSource-1">BufferSource</a></code> typedef rather than <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-8">ArrayBuffer</a></code> or any of the view types.</p>
<p>When designing APIs that create and return a buffer, it is recommended
to use the <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-9">ArrayBuffer</a></code> type rather than <code class="idl"><a data-link-type="idl" href="#idl-Uint8Array" id="ref-for-idl-Uint8Array-2">Uint8Array</a></code>.</p>
</div>
<p>Attempting to <a data-link-type="dfn" href="#dfn-get-buffer-source-reference" id="ref-for-dfn-get-buffer-source-reference-1">get a reference to</a> or <a data-link-type="dfn" href="#dfn-get-buffer-source-copy" id="ref-for-dfn-get-buffer-source-copy-1">get a copy of the bytes held by a buffer source</a> when the <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-10">ArrayBuffer</a></code> has been <a data-link-type="dfn" href="#dfn-detach" id="ref-for-dfn-detach-1">detached</a> will fail in a language binding-specific manner.</p>
<p class="note" role="note">Note: See <a href="#es-buffer-source-types">§3.2.32 Buffer source types</a> below for
how interacting with buffer source types works in the ECMAScript language binding.</p>
<p class="issue" id="issue-2379a917"><a class="self-link" href="#issue-2379a917"></a> We should include an example of specification text that uses these types and terms. </p>
<pre class="grammar" id="prod-BufferRelatedType">BufferRelatedType :
"ArrayBuffer"
"DataView"
"Int8Array"
"Int16Array"
"Int32Array"
"Uint8Array"
"Uint16Array"
"Uint32Array"
"Uint8ClampedArray"
"Float32Array"
"Float64Array"
</pre>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="interface" data-export="" data-level="2.11.32" data-lt="FrozenArray|FrozenArray<T>" id="idl-frozen-array"><span class="secno">2.11.32. </span><span class="content">Frozen array types — FrozenArray<<var>T</var>></span><span id="dom-FrozenArray"></span></h4>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-frozen-array-type">frozen array type</dfn> is a parameterized
type whose values are references to objects that hold a fixed length array
of unmodifiable values. The values in the array are of type <var>T</var>.</p>
<p>Since <a class="idl-code" data-link-type="interface" href="#idl-frozen-array" id="ref-for-idl-frozen-array-1">FrozenArray<<var>T</var>></a> values
are references, they are unlike <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-9">sequence types</a>,
which are lists of values that are passed by value.</p>
<p>There is no way to represent a constant frozen array value in IDL.</p>
<p>The <a data-link-type="dfn" href="#dfn-type-name" id="ref-for-dfn-type-name-32">type name</a> of a frozen array
type is the concatenation of the type name for <var>T</var> and the string
“Array”.</p>
<h3 class="heading settled" data-level="2.12" id="idl-extended-attributes"><span class="secno">2.12. </span><span class="content">Extended attributes</span><a class="self-link" href="#idl-extended-attributes"></a></h3>
<p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-extended-attribute">extended attribute</dfn> is an annotation
that can appear on
definitions, <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-10">interface members</a>, <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-2">namespace members</a>, <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-13">dictionary members</a>,
and <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-29">operation</a> arguments, and
is used to control how language bindings will handle those constructs.
Extended attributes are specified with an <emu-nt><a href="#prod-ExtendedAttributeList">ExtendedAttributeList</a></emu-nt>,
which is a square bracket enclosed, comma separated list of <emu-nt><a href="#prod-ExtendedAttribute">ExtendedAttribute</a></emu-nt>s.</p>
<p>The <emu-nt><a href="#prod-ExtendedAttribute">ExtendedAttribute</a></emu-nt> grammar symbol matches nearly any sequence of tokens, however the <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-21">extended attributes</a> defined in this document only accept a more restricted syntax.
Any extended attribute encountered in an <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-31">IDL fragment</a> is
matched against the following six grammar symbols to determine
which form (or forms) it is in:</p>
<table class="vert data">
<tbody>
<tr>
<th>Grammar symbol
<th>Form
<th>Example
<tr>
<td> <emu-nt><a href="#prod-ExtendedAttributeNoArgs">ExtendedAttributeNoArgs</a></emu-nt>
<td> <dfn class="dfn-paneled" data-dfn-for="extended attribute" data-dfn-type="dfn" data-export="" id="dfn-xattr-no-arguments">takes no arguments</dfn>
<td> <code>[Replaceable]</code>
<tr>
<td> <emu-nt><a href="#prod-ExtendedAttributeArgList">ExtendedAttributeArgList</a></emu-nt>
<td> <dfn class="dfn-paneled" data-dfn-for="extended attribute" data-dfn-type="dfn" data-export="" id="dfn-xattr-argument-list">takes an argument list</dfn>
<td> <code>[Constructor(double x, double y)]</code>
<tr>
<td> <emu-nt><a href="#prod-ExtendedAttributeNamedArgList">ExtendedAttributeNamedArgList</a></emu-nt>
<td> <dfn class="dfn-paneled" data-dfn-for="extended attribute" data-dfn-type="dfn" data-export="" id="dfn-xattr-named-argument-list">takes a named argument list</dfn>
<td> <code>[NamedConstructor=Image(DOMString src)]</code>
<tr>
<td> <emu-nt><a href="#prod-ExtendedAttributeIdent">ExtendedAttributeIdent</a></emu-nt>
<td> <dfn class="dfn-paneled" data-dfn-for="extended attribute" data-dfn-type="dfn" data-export="" id="dfn-xattr-identifier">takes an identifier</dfn>
<td> <code>[PutForwards=name]</code>
<tr>
<td> <emu-nt><a href="#prod-ExtendedAttributeIdentList">ExtendedAttributeIdentList</a></emu-nt>
<td> <dfn class="dfn-paneled" data-dfn-for="extended attribute" data-dfn-type="dfn" data-export="" id="dfn-xattr-identifier-list">takes an identifier list</dfn>
<td> <code>[Exposed=(Window,Worker)]</code>
</table>
<p>This specification defines a number of extended attributes that
are applicable to the ECMAScript language binding, which are described in <a href="#es-extended-attributes">§3.3 ECMAScript-specific extended attributes</a>.
Each extended attribute definition will state which of the above
six forms are allowed.</p>
<pre class="grammar" id="prod-ExtendedAttributeList">ExtendedAttributeList :
"[" ExtendedAttribute ExtendedAttributes "]"
ε
</pre>
<pre class="grammar" id="prod-ExtendedAttributes">ExtendedAttributes :
"," ExtendedAttribute ExtendedAttributes
ε
</pre>
<pre class="grammar" id="prod-ExtendedAttribute">ExtendedAttribute :
"(" ExtendedAttributeInner ")" ExtendedAttributeRest
"[" ExtendedAttributeInner "]" ExtendedAttributeRest
"{" ExtendedAttributeInner "}" ExtendedAttributeRest
Other ExtendedAttributeRest
</pre>
<pre class="grammar" id="prod-ExtendedAttributeRest">ExtendedAttributeRest :
ExtendedAttribute
ε
</pre>
<pre class="grammar" id="prod-ExtendedAttributeInner">ExtendedAttributeInner :
"(" ExtendedAttributeInner ")" ExtendedAttributeInner
"[" ExtendedAttributeInner "]" ExtendedAttributeInner
"{" ExtendedAttributeInner "}" ExtendedAttributeInner
OtherOrComma ExtendedAttributeInner
ε
</pre>
<pre class="grammar" id="prod-Other">Other :
integer
float
identifier
string
other
"-"
"-Infinity"
"."
"..."
":"
";"
"<"
"="
">"
"?"
"ByteString"
"DOMString"
"FrozenArray"
"Infinity"
"NaN"
"RegExp"
"USVString"
"any"
"boolean"
"byte"
"double"
"false"
"float"
"long"
"null"
"object"
"octet"
"or"
"optional"
"sequence"
"short"
"true"
"unsigned"
"void"
ArgumentNameKeyword
BufferRelatedType
</pre>
<pre class="grammar" id="prod-OtherOrComma">OtherOrComma :
Other
","
</pre>
<pre class="grammar" id="prod-IdentifierList">IdentifierList :
identifier Identifiers
</pre>
<div data-fill-with="grammar-Identifiers"></div>
<pre class="grammar" id="prod-ExtendedAttributeNoArgs">ExtendedAttributeNoArgs :
identifier
</pre>
<pre class="grammar" id="prod-ExtendedAttributeArgList">ExtendedAttributeArgList :
identifier "(" ArgumentList ")"
</pre>
<pre class="grammar" id="prod-ExtendedAttributeIdent">ExtendedAttributeIdent :
identifier "=" identifier
</pre>
<pre class="grammar" id="prod-ExtendedAttributeIdentList">ExtendedAttributeIdentList :
identifier "=" "(" IdentifierList ")"
</pre>
<pre class="grammar" id="prod-ExtendedAttributeNamedArgList">ExtendedAttributeNamedArgList :
identifier "=" identifier "(" ArgumentList ")"
</pre>
<h2 class="heading settled" data-level="3" id="ecmascript-binding"><span class="secno">3. </span><span class="content">ECMAScript binding</span><a class="self-link" href="#ecmascript-binding"></a></h2>
<p>This section describes how definitions written with the IDL defined in <a href="#idl">§2 Interface definition language</a> correspond to particular constructs
in ECMAScript, as defined by the <cite>ECMAScript Language Specification 6th Edition</cite> <a data-link-type="biblio" href="#biblio-ecma-262">[ECMA-262]</a>.</p>
<p>Objects defined in this section have internal properties as described in
ECMA-262 <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots">sections 9.1</a> and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-built-in-function-objects-call-thisargument-argumentslist">9.3.1</a> unless otherwise specified, in which case one or
more of the following are redefined in accordance with the rules for exotic objects:
[[Call]],
[[Set]],
[[DefineOwnProperty]],
[[GetOwnProperty]],
[[Delete]] and
[[HasInstance]].</p>
<p>Other specifications may override the definitions
of any internal method of a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-9">platform object</a> that is an instance of an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-52">interface</a>.</p>
<p class="advisement"> As overriding internal ECMAScript object methods is a low level operation and
can result in objects that behave differently from ordinary objects,
this facility should not be used unless necessary
for security or compatibility. The expectation is that this will be used
for <a href="https://github.com/annevk/html-cross-origin-objects/">Location objects
and possibly WindowProxy objects</a>. </p>
<p>Unless otherwise specified, the [[Extensible]] internal property
of objects defined in this section has the value <emu-val>true</emu-val>.</p>
<p>Unless otherwise specified, the [[Prototype]] internal property
of objects defined in this section is the <emu-val>Object</emu-val> prototype object.</p>
<p>Some objects described in this section are defined to have a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-class-string">class string</dfn>,
which is the string to include in the string returned from Object.prototype.toString.
If an object has a class string, then the object must,
at the time it is created, have a property whose name is the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@toStringTag</a> symbol
and whose value is the specified string.</p>
<p class="issue" id="issue-da7d3178"><a class="self-link" href="#issue-da7d3178"></a> Should define whether <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@toStringTag</a> is writable, enumerable and configurable.
All <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@toStringTag</a> properties in the ES6 spec are non-writable and non-enumerable,
and configurable. </p>
<p>If an object is defined to be a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-function-object">function object</dfn>, then
it has characteristics as follows:</p>
<ul>
<li data-md="">
<p>Its [[Prototype]] internal property is <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-function-prototype-object">%FunctionPrototype%</a> unless otherwise specified.</p>
<li data-md="">
<p>Its [[Get]] internal property is set as described in <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-get-p-receiver">ECMA-262 section 9.1.8</a>.</p>
<li data-md="">
<p>Its [[Construct]] internal property is set as described in <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-function-@@create">ECMA-262 section 19.2.2.3</a>.</p>
<li data-md="">
<p>Its @@hasInstance property is set as described in <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-function.prototype-@@hasinstance">ECMA-262 section 19.2.3.8</a>, unless otherwise specified.</p>
</ul>
<p class="issue" id="issue-459a816a"><a class="self-link" href="#issue-459a816a"></a> The list above needs updating for the latest ES6 draft. </p>
<p id="ecmascript-abstractop"> Algorithms in this section use the conventions described in <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">ECMA-262 section 5.2</a>, such as the use of steps and substeps, the use of mathematical
operations, and so on. The <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toboolean">ToBoolean</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint16">ToUint16</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toint32">ToInt32</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isaccessordescriptor">IsAccessorDescriptor</a> and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isdatadescriptor">IsDataDescriptor</a> abstract operations and the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type(x)</a> notation referenced in this section are defined in ECMA-262 sections 6 and 7. </p>
<p>When an algorithm says to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="es throw" id="ecmascript-throw">throw a <emu-val><i>Something</i>Error</emu-val></dfn> then this means to construct a new ECMAScript <emu-val><i>Something</i>Error</emu-val> object
and to throw it, just as the algorithms in ECMA-262 do.</p>
<p>Note that algorithm steps can call in to other algorithms and abstract operations and
not explicitly handle exceptions that are thrown from them. When an exception
is thrown by an algorithm or abstract operation and it is not explicitly
handled by the caller, then it is taken to end the algorithm and propagate out
to its caller, and so on.</p>
<div class="example" id="example-f1aacd6f">
<a class="self-link" href="#example-f1aacd6f"></a>
<p>Consider the following algorithm:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be the ECMAScript value passed in to this algorithm.</p>
<li data-md="">
<p>Let <var>y</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>x</var>).</p>
<li data-md="">
<p>Return <var>y</var>.</p>
</ol>
<p>Since <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a> can throw an exception (for example if passed the object <code>({ toString: function() { throw 1 } })</code>), and the exception is
not handled in the above algorithm, if one is thrown then it causes this
algorithm to end and for the exception to propagate out to its caller, if there
is one.</p>
</div>
<h3 class="heading settled" data-level="3.1" id="es-environment"><span class="secno">3.1. </span><span class="content">ECMAScript environment</span><a class="self-link" href="#es-environment"></a></h3>
<p>In an ECMAScript implementation of a given set of <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-32">IDL fragments</a>,
there will exist a number of ECMAScript objects that correspond to
definitions in those <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-33">IDL fragments</a>.
These objects are termed the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-initial-object">initial objects</dfn>,
and comprise the following:</p>
<ul>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-2">interface objects</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-named-constructor" id="ref-for-dfn-named-constructor-1">named constructors</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-3">interface prototype objects</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-1">named properties objects</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-iterator-prototype-object" id="ref-for-dfn-iterator-prototype-object-1">iterator prototype objects</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-attribute-getter" id="ref-for-dfn-attribute-getter-1">attribute getters</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-attribute-setter" id="ref-for-dfn-attribute-setter-1">attribute setters</a></p>
<li data-md="">
<p><a href="#es-operations">the <emu-val>Function</emu-val> objects that correspond to operations</a></p>
<li data-md="">
<p><a href="#es-stringifier">the <emu-val>Function</emu-val> objects that correspond to stringifiers</a></p>
<li data-md="">
<p><a href="#es-serializer">the <emu-val>Function</emu-val> objects that correspond to serializers</a></p>
<li data-md="">
<p><a href="#es-iterators">the <emu-val>Function</emu-val> objects that correspond to iterators</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-default-unforgeable-valueOf-function" id="ref-for-dfn-default-unforgeable-valueOf-function-1">default unforgeable valueOf functions</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-map-size-getter" id="ref-for-dfn-map-size-getter-1">map size getters</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-DOMException-constructor-object" id="ref-for-dfn-DOMException-constructor-object-1">DOMException constructor objects</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-DOMException-prototype-object" id="ref-for-dfn-DOMException-prototype-object-1">DOMException prototype objects</a></p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-2">named properties objects</a></p>
</ul>
<p>Each <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-code-realms">ECMAScript global environment</a> must have its own unique set of each of
the <a data-link-type="dfn" href="#dfn-initial-object" id="ref-for-dfn-initial-object-1">initial objects</a>, created
before control enters any ECMAScript execution context associated with the
environment, but after the global object for that environment is created. The [[Prototype]]s
of all initial objects in a given global environment must come from
that same global environment.</p>
<div class="example" id="example-bebf14c4">
<a class="self-link" href="#example-bebf14c4"></a>
<p>In an HTML user agent, multiple global environments can exist when
multiple frames or windows are created. Each frame or window will have
its own set of <a data-link-type="dfn" href="#dfn-initial-object" id="ref-for-dfn-initial-object-2">initial objects</a>,
which the following HTML document demonstrates:</p>
<pre class="highlight"><span class="cp"><!DOCTYPE html></span>
<span class="p"><</span><span class="nt">title</span><span class="p">></span>Different global environments<span class="p"><</span><span class="p">/</span><span class="nt">title</span><span class="p">></span>
<span class="p"><</span><span class="nt">iframe</span> <span class="na">id</span><span class="o">=</span><span class="s">a</span><span class="p">></span><span class="p"><</span><span class="p">/</span><span class="nt">iframe</span><span class="p">></span>
<span class="p"><</span><span class="nt">script</span><span class="p">></span>
<span class="kd">var</span> iframe <span class="o">=</span> document<span class="p">.</span>getElementById<span class="p">(</span><span class="s2">"a"</span><span class="p">)</span><span class="p">;</span>
<span class="kd">var</span> w <span class="o">=</span> iframe<span class="p">.</span>contentWindow<span class="p">;</span> <span class="c1">// The global object in the frame
</span>
Object <span class="o">==</span> w<span class="p">.</span>Object<span class="p">;</span> <span class="c1">// Evaluates to false, per ECMA-262
</span>Node <span class="o">==</span> w<span class="p">.</span>Node<span class="p">;</span> <span class="c1">// Evaluates to false
</span>iframe <span class="k">instanceof</span> w<span class="p">.</span>Node<span class="p">;</span> <span class="c1">// Evaluates to false
</span>iframe <span class="k">instanceof</span> w<span class="p">.</span>Object<span class="p">;</span> <span class="c1">// Evaluates to false
</span>iframe<span class="p">.</span>appendChild <span class="k">instanceof</span> Function<span class="p">;</span> <span class="c1">// Evaluates to true
</span>iframe<span class="p">.</span>appendChild <span class="k">instanceof</span> w<span class="p">.</span>Function<span class="p">;</span> <span class="c1">// Evaluates to false
</span><span class="p"><</span><span class="p">/</span><span class="nt">script</span><span class="p">></span>
</pre>
</div>
<p>Unless otherwise specified, each ECMAScript global environment <dfn class="dfn-paneled" data-dfn-for="ECMAScript global environment" data-dfn-type="dfn" data-export="" id="dfn-expose">exposes</dfn> all <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-53">interfaces</a> that the implementation supports. If a given ECMAScript global environment does not
expose an interface, then the requirements given in <a href="#es-interfaces">§3.6 Interfaces</a> are
not followed for that interface.</p>
<p class="note" role="note">Note: This allows, for example, ECMAScript global environments for Web Workers to <a data-link-type="dfn" href="#dfn-expose" id="ref-for-dfn-expose-1">expose</a> different sets of supported interfaces from those exposed in environments
for Web pages.</p>
<p>Although at the time of this writing the ECMAScript specification does not reflect this,
every ECMAScript object must have an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-associated-realm">associated <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-code-realms">Realm</a></dfn>. The mechanisms
for associating objects with Realms are, for now, underspecified. However, we note that
in the case of <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-10">platform objects</a>, the
associated Realm is equal to the object’s <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-relevant-realm">relevant Realm</a>, and
for non-exotic function objects (i.e. not callable proxies, and not bound functions)
the associated Realm is equal to the value of the function object’s [[Realm]] internal
slot.</p>
<h3 class="heading settled" data-level="3.2" id="es-type-mapping"><span class="secno">3.2. </span><span class="content">ECMAScript type mapping</span><a class="self-link" href="#es-type-mapping"></a></h3>
<p>This section describes how types in the IDL map to types in ECMAScript.</p>
<p>Each sub-section below describes how values of a given IDL type are represented
in ECMAScript. For each IDL type, it is described how ECMAScript values are <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="converted to an IDL value|converted to IDL values" id="dfn-convert-ecmascript-to-idl-value">converted to an IDL value</dfn> when passed to a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-11">platform object</a> expecting that type, and how IDL values
of that type are <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" data-lt="converted to an ECMAScript value|converted to ECMAScript values" id="dfn-convert-idl-to-ecmascript-value">converted to ECMAScript values</dfn> when returned from a platform object.</p>
<h4 class="heading settled" data-level="3.2.1" id="es-any"><span class="secno">3.2.1. </span><span class="content">any</span><a class="self-link" href="#es-any"></a></h4>
<p>Since the IDL <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-9">any</a></code> type
is the union of all other IDL types, it can correspond to any
ECMAScript value type.</p>
<p id="es-to-any"> How to <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-1">convert an ECMAScript value</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-10">any</a></code> value depends on the type of the
ECMAScript value: </p>
<dl class="switch">
<dt data-md="">
<p>The <emu-val>undefined</emu-val> value</p>
<dd data-md="">
<p>The IDL value is an <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-5">object</a></code> reference
to a special object that represents the ECMAScript <emu-val>undefined</emu-val> value.</p>
<dt data-md="">
<p>The <emu-val>null</emu-val> value</p>
<dd data-md="">
<p>The IDL value is the <emu-val>null</emu-val> <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-6">object?</a></code> reference.</p>
<dt data-md="">
<p>A <emu-val>Boolean</emu-val> value</p>
<dd data-md="">
<p>The IDL value is the <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-10">boolean</a></code> value that represents the same truth value.</p>
<dt data-md="">
<p>A <emu-val>Number</emu-val> value</p>
<dd data-md="">
<p>The IDL value is that which is obtained
by following the rules for converting the <emu-val>Number</emu-val> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-10">unrestricted double</a></code> value,
as described in <a href="#es-unrestricted-double">§3.2.15 unrestricted double</a>.</p>
<dt data-md="">
<p>A <emu-val>String</emu-val> value</p>
<dd data-md="">
<p>The IDL value is that which is obtained
by following the rules for converting the <emu-val>String</emu-val> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-38">DOMString</a></code> value,
as described in <a href="#es-DOMString">§3.2.16 DOMString</a>.</p>
<dt data-md="">
<p>An <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-7">object</a></code> value</p>
<dd data-md="">
<p>The IDL value is an <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-8">object</a></code> value that
references the same object.</p>
</dl>
<p id="any-to-es"> An IDL <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-11">any</a></code> value is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-1">converted to an ECMAScript value</a> as follows. If the value is an <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-9">object</a></code> reference to a special object that represents an ECMAScript <emu-val>undefined</emu-val> value, then it is converted to the ECMAScript <emu-val>undefined</emu-val> value. Otherwise,
the rules for converting the <a data-link-type="dfn" href="#dfn-specific-type" id="ref-for-dfn-specific-type-4">specific type</a> of the IDL <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-12">any</a></code> value
as described in the remainder of this section are performed. </p>
<h4 class="heading settled" data-level="3.2.2" id="es-void"><span class="secno">3.2.2. </span><span class="content">void</span><a class="self-link" href="#es-void"></a></h4>
<p>The only place that the <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-1">void</a></code> type may appear
in IDL is as the <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-3">return type</a> of an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-30">operation</a>. Functions on <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-12">platform objects</a> that implement an operation whose IDL specifies a <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-2">void</a></code> return type must return the <emu-val>undefined</emu-val> value.</p>
<p>ECMAScript functions that implement an operation whose IDL
specifies a <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-3">void</a></code> return type
may return any value, which will be discarded.</p>
<h4 class="heading settled" data-level="3.2.3" id="es-boolean"><span class="secno">3.2.3. </span><span class="content">boolean</span><a class="self-link" href="#es-boolean"></a></h4>
<p id="es-to-boolean"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-2">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-11">boolean</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be the result of computing <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toboolean">ToBoolean</a>(<var>V</var>).</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-12">boolean</a></code> value that is the one that represents the same truth value as the ECMAScript <emu-val>Boolean</emu-val> value <var>x</var>.</p>
</ol>
<p id="boolean-to-es"> The IDL <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-13">boolean</a></code> value <emu-val>true</emu-val> is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-2">converted</a> to
the ECMAScript <emu-val>true</emu-val> value and the IDL <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-14">boolean</a></code> value <emu-val>false</emu-val> is converted to the ECMAScript <emu-val>false</emu-val> value. </p>
<h4 class="heading settled" data-level="3.2.4" id="es-byte"><span class="secno">3.2.4. </span><span class="content">byte</span><a class="self-link" href="#es-byte"></a></h4>
<p id="es-to-byte"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-3">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-6">byte</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-25">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-4">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-22">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-31">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-5">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-14">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-6">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-1">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < −2<sup>7</sup> or <var>x</var> > 2<sup>7</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-2">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-7">byte</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-26">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-4">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-23">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-32">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-5">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-15">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-6">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, −2<sup>7</sup>), 2<sup>7</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-8">byte</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +0, −0, +∞, or −∞, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-9">byte</a></code> value that represents 0.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>Set <var>x</var> to <var>x</var> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">modulo</a> 2<sup>8</sup>.</p>
<li data-md="">
<p>If <var>x</var> ≥ 2<sup>7</sup>, return the IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-10">byte</a></code> value that represents the same numeric value as <var>x</var> − 2<sup>8</sup>.
Otherwise, return the IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-11">byte</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="byte-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-3">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-12">byte</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> that represents
the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-byte" id="ref-for-idl-byte-13">byte</a></code> value.
The <emu-val>Number</emu-val> value will be an integer in the range [−128, 127]. </p>
<h4 class="heading settled" data-level="3.2.5" id="es-octet"><span class="secno">3.2.5. </span><span class="content">octet</span><a class="self-link" href="#es-octet"></a></h4>
<p id="es-to-octet"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-4">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-6">octet</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-27">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-7">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-24">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-33">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-8">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-16">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-9">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-3">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < 0 or <var>x</var> > 2<sup>8</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-4">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-7">octet</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-28">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-7">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-25">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-34">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-8">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-17">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-9">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, 0), 2<sup>8</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-8">octet</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +0, −0, +∞, or −∞, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-9">octet</a></code> value that represents 0.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>Set <var>x</var> to <var>x</var> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">modulo</a> 2<sup>8</sup>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-10">octet</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="octet-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-4">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-11">octet</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> that represents
the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-12">octet</a></code> value.
The <emu-val>Number</emu-val> value will be an integer in the range [0, 255]. </p>
<h4 class="heading settled" data-level="3.2.6" id="es-short"><span class="secno">3.2.6. </span><span class="content">short</span><a class="self-link" href="#es-short"></a></h4>
<p id="es-to-short"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-5">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-5">short</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-29">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-10">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-26">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-35">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-11">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-18">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-12">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-5">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < −2<sup>15</sup> or <var>x</var> > 2<sup>15</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-6">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-6">short</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-30">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-10">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-27">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-36">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-11">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-19">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-12">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, −2<sup>15</sup>), 2<sup>15</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-7">short</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +0, −0, +∞, or −∞, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-8">short</a></code> value that represents 0.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>Set <var>x</var> to <var>x</var> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">modulo</a> 2<sup>16</sup>.</p>
<li data-md="">
<p>If <var>x</var> ≥ 2<sup>15</sup>, return the IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-9">short</a></code> value that represents the same numeric value as <var>x</var> − 2<sup>16</sup>.
Otherwise, return the IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-10">short</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="short-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-5">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-11">short</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> that represents the
same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-short" id="ref-for-idl-short-12">short</a></code> value.
The <emu-val>Number</emu-val> value will be an integer in the range [−32768, 32767]. </p>
<h4 class="heading settled" data-level="3.2.7" id="es-unsigned-short"><span class="secno">3.2.7. </span><span class="content">unsigned short</span><a class="self-link" href="#es-unsigned-short"></a></h4>
<p id="es-to-unsigned-short"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-6">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-6">unsigned short</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-31">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-13">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-28">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-37">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-14">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-20">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-15">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-7">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < 0 or <var>x</var> > 2<sup>16</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-8">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-7">unsigned short</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-32">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-13">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-29">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-38">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-14">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-21">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-15">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, 0), 2<sup>16</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-8">unsigned short</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint16">ToUint16</a>(<var>x</var>).</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-9">unsigned short</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="unsigned-short-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-6">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-10">unsigned short</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> that
represents the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-short" id="ref-for-idl-unsigned-short-11">unsigned short</a></code> value.
The <emu-val>Number</emu-val> value will be an integer in the range [0, 65535]. </p>
<h4 class="heading settled" data-level="3.2.8" id="es-long"><span class="secno">3.2.8. </span><span class="content">long</span><a class="self-link" href="#es-long"></a></h4>
<p id="es-to-long"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-7">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-6">long</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-33">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-16">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-30">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-39">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-17">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-22">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-18">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-9">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < −2<sup>31</sup> or <var>x</var> > 2<sup>31</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-10">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-7">long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-34">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-16">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-31">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-40">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-17">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-23">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-18">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, −2<sup>31</sup>), 2<sup>31</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-8">long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toint32">ToInt32</a>(<var>x</var>).</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-9">long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="long-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-7">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-10">long</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> that
represents the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-long" id="ref-for-idl-long-11">long</a></code> value.
The <emu-val>Number</emu-val> value will be an integer in the range [−2147483648, 2147483647]. </p>
<h4 class="heading settled" data-level="3.2.9" id="es-unsigned-long"><span class="secno">3.2.9. </span><span class="content">unsigned long</span><a class="self-link" href="#es-unsigned-long"></a></h4>
<p id="es-to-unsigned-long"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-8">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-10">unsigned long</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-35">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-19">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-32">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-41">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-20">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-24">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-21">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-11">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < 0 or <var>x</var> > 2<sup>32</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-12">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-11">unsigned long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-36">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-19">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-33">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-42">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-20">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-25">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-21">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, 0), 2<sup>32</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-12">unsigned long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>(<var>x</var>).</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-13">unsigned long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="unsigned-long-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-8">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-14">unsigned long</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> that
represents the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-15">unsigned long</a></code> value.
The <emu-val>Number</emu-val> value will be an integer in the range [0, 4294967295]. </p>
<h4 class="heading settled" data-level="3.2.10" id="es-long-long"><span class="secno">3.2.10. </span><span class="content">long long</span><a class="self-link" href="#es-long-long"></a></h4>
<p id="es-to-long-long"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-9">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-6">long long</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-37">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-22">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-34">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-43">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-23">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-26">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-24">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-13">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < −2<sup>53</sup> + 1 or <var>x</var> > 2<sup>53</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-14">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-7">long long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-38">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-22">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-35">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-44">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-23">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-27">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-24">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, −2<sup>53</sup> + 1), 2<sup>53</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-8">long long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +0, −0, +∞, or −∞, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-9">long long</a></code> value that represents 0.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>Set <var>x</var> to <var>x</var> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">modulo</a> 2<sup>64</sup>.</p>
<li data-md="">
<p>If <var>x</var> is greater than or equal to 2<sup>63</sup>, then set <var>x</var> to <var>x</var> − 2<sup>64</sup>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-10">long long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="long-long-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-9">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-11">long long</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> value that
represents the closest numeric value to the <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-12">long long</a></code>,
choosing the numeric value with an <em>even significand</em> if there are
two <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">equally close values</a>.
If the <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-13">long long</a></code> is in the range
[−2<sup>53</sup> + 1, 2<sup>53</sup> − 1], then the <emu-val>Number</emu-val> will be able to represent exactly the same value as the <code class="idl"><a data-link-type="idl" href="#idl-long-long" id="ref-for-idl-long-long-14">long long</a></code>. </p>
<h4 class="heading settled" data-level="3.2.11" id="es-unsigned-long-long"><span class="secno">3.2.11. </span><span class="content">unsigned long long</span><a class="self-link" href="#es-unsigned-long-long"></a></h4>
<p id="es-to-unsigned-long-long"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-10">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-6">unsigned long long</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-39">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-25">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-36">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-45">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-26">EnforceRange</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-28">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-27">EnforceRange</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +∞, or −∞, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-15">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>If <var>x</var> < 0 or <var>x</var> > 2<sup>53</sup> − 1, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-16">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-7">unsigned long long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is not <emu-val>NaN</emu-val> and the conversion to an IDL value is being performed due to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-40">attribute</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-25">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-37">extended attribute</a>,</p>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-46">operation</a> argument annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-26">Clamp</a></code>] extended attribute, or</p>
<li data-md="">
<p><var>V</var> is being used as the value of a <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-29">dictionary member</a> annotated with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-27">Clamp</a></code>] extended attribute,</p>
</ul>
<p>then:</p>
<ol>
<li data-md="">
<p>Set <var>x</var> to min(max(<var>x</var>, 0), 2<sup>53</sup> − 1).</p>
<li data-md="">
<p>Round <var>x</var> to the nearest integer, choosing the even integer if it lies halfway between two, and choosing +0 rather than −0.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-8">unsigned long long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, +0, −0, +∞, or −∞, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-9">unsigned long long</a></code> value that represents 0.</p>
<li data-md="">
<p>Set <var>x</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>(<var>x</var>) * <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>(<var>x</var>)).</p>
<li data-md="">
<p>Set <var>x</var> to <var>x</var> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">modulo</a> 2<sup>64</sup>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-10">unsigned long long</a></code> value that represents the same numeric value as <var>x</var>.</p>
</ol>
<p id="unsigned-long-long-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-10">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-11">unsigned long long</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val> value that
represents the closest numeric value to the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-12">unsigned long long</a></code>,
choosing the numeric value with an <em>even significand</em> if there are
two <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">equally close values</a>.
If the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-13">unsigned long long</a></code> is less than or equal to 2<sup>53</sup> − 1,
then the <emu-val>Number</emu-val> will be able to
represent exactly the same value as the <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long-long" id="ref-for-idl-unsigned-long-long-14">unsigned long long</a></code>. </p>
<h4 class="heading settled" data-level="3.2.12" id="es-float"><span class="secno">3.2.12. </span><span class="content">float</span><a class="self-link" href="#es-float"></a></h4>
<p id="es-to-float"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-11">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-9">float</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, <emu-val>+Infinity</emu-val> or <emu-val>−Infinity</emu-val>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-17">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>S</var> be the set of finite IEEE 754 single-precision floating
point values except −0, but with two special values added: 2<sup>128</sup> and
−2<sup>128</sup>.</p>
<li data-md="">
<p>Let <var>y</var> be the number in <var>S</var> that is closest
to <var>x</var>, selecting the number with an <em>even significand</em> if there are two <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">equally close values</a>.
(The two special values 2<sup>128</sup> and −2<sup>128</sup> are considered to have even significands for this purpose.)</p>
<li data-md="">
<p>If <var>y</var> is 2<sup>128</sup> or −2<sup>128</sup>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-18">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>If <var>y</var> is +0 and <var>x</var> is negative, return −0.</p>
<li data-md="">
<p>Return <var>y</var>.</p>
</ol>
<p id="float-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-11">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-10">float</a></code> value to an ECMAScript
value is the <emu-val>Number</emu-val> value that represents the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-float" id="ref-for-idl-float-11">float</a></code> value. </p>
<h4 class="heading settled" data-level="3.2.13" id="es-unrestricted-float"><span class="secno">3.2.13. </span><span class="content">unrestricted float</span><a class="self-link" href="#es-unrestricted-float"></a></h4>
<p id="es-to-unrestricted-float"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-12">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-9">unrestricted float</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-10">unrestricted float</a></code> value that represents the IEEE 754 NaN value with the bit pattern 0x7fc00000 <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a>.</p>
<li data-md="">
<p>Let <var>S</var> be the set of finite IEEE 754 single-precision floating
point values except −0, but with two special values added: 2<sup>128</sup> and
−2<sup>128</sup>.</p>
<li data-md="">
<p>Let <var>y</var> be the number in <var>S</var> that is closest
to <var>x</var>, selecting the number with an <em>even significand</em> if there are two <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">equally close values</a>.
(The two special values 2<sup>128</sup> and −2<sup>128</sup> are considered to have even significands for this purpose.)</p>
<li data-md="">
<p>If <var>y</var> is 2<sup>128</sup>, return +∞.</p>
<li data-md="">
<p>If <var>y</var> is −2<sup>128</sup>, return −∞.</p>
<li data-md="">
<p>If <var>y</var> is +0 and <var>x</var> is negative, return −0.</p>
<li data-md="">
<p>Return <var>y</var>.</p>
</ol>
<p class="note" role="note">Note: Since there is only a single ECMAScript <emu-val>NaN</emu-val> value,
it must be canonicalized to a particular single precision IEEE 754 NaN value. The NaN value
mentioned above is chosen simply because it is the quiet NaN with the lowest
value when its bit pattern is interpreted as an unsigned 32 bit integer.</p>
<p id="unrestricted-float-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-12">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-11">unrestricted float</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val>: </p>
<ul>
<li data-md="">
<p>If the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-12">unrestricted float</a></code> value is a NaN,
then the <emu-val>Number</emu-val> value is <emu-val>NaN</emu-val>.</p>
<li data-md="">
<p>Otherwise, the <emu-val>Number</emu-val> value is
the one that represents the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-float" id="ref-for-idl-unrestricted-float-13">unrestricted float</a></code> value.</p>
</ul>
<h4 class="heading settled" data-level="3.2.14" id="es-double"><span class="secno">3.2.14. </span><span class="content">double</span><a class="self-link" href="#es-double"></a></h4>
<p id="es-to-double"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-13">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-14">double</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, <emu-val>+Infinity</emu-val> or <emu-val>−Infinity</emu-val>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-19">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-15">double</a></code> value
that has the same numeric value as <var>x</var>.</p>
</ol>
<p id="double-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-13">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-16">double</a></code> value to an ECMAScript
value is the <emu-val>Number</emu-val> value that represents the
same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-double" id="ref-for-idl-double-17">double</a></code> value. </p>
<h4 class="heading settled" data-level="3.2.15" id="es-unrestricted-double"><span class="secno">3.2.15. </span><span class="content">unrestricted double</span><a class="self-link" href="#es-unrestricted-double"></a></h4>
<p id="es-to-unrestricted-double"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-14">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-11">unrestricted double</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tonumber">ToNumber</a>(<var>V</var>).</p>
<li data-md="">
<p>If <var>x</var> is <emu-val>NaN</emu-val>, then return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-12">unrestricted double</a></code> value that represents the IEEE 754 NaN value with the bit pattern 0x7ff8000000000000 <a data-link-type="biblio" href="#biblio-ieee-754">[IEEE-754]</a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-13">unrestricted double</a></code> value
that has the same numeric value as <var>x</var>.</p>
</ol>
<p class="note" role="note">Note: Since there is only a single ECMAScript <emu-val>NaN</emu-val> value,
it must be canonicalized to a particular double precision IEEE 754 NaN value. The NaN value
mentioned above is chosen simply because it is the quiet NaN with the lowest
value when its bit pattern is interpreted as an unsigned 64 bit integer.</p>
<p id="unrestricted-double-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-14">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-14">unrestricted double</a></code> value to an ECMAScript
value is a <emu-val>Number</emu-val>: </p>
<ul>
<li data-md="">
<p>If the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-15">unrestricted double</a></code> value is a NaN,
then the <emu-val>Number</emu-val> value is <emu-val>NaN</emu-val>.</p>
<li data-md="">
<p>Otherwise, the <emu-val>Number</emu-val> value is
the one that represents the same numeric value as the IDL <code class="idl"><a data-link-type="idl" href="#idl-unrestricted-double" id="ref-for-idl-unrestricted-double-16">unrestricted double</a></code> value.</p>
</ul>
<h4 class="heading settled" data-level="3.2.16" id="es-DOMString"><span class="secno">3.2.16. </span><span class="content">DOMString</span><a class="self-link" href="#es-DOMString"></a></h4>
<p id="es-to-DOMString"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-15">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-39">DOMString</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <var>V</var> is <emu-val>null</emu-val> and the conversion to an IDL value is being performed due
to any of the following:</p>
<ul>
<li data-md="">
<p><var>V</var> is being passed as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-47">operation</a> argument that is annotated with [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-4">TreatNullAs</a></code>],</p>
<li data-md="">
<p><var>V</var> is being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-41">attribute</a> annotated with [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-5">TreatNullAs</a></code>],</p>
<li data-md="">
<p><var>V</var> is being returned from a <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-6">user object</a> implementation of an
operation annotated with [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-6">TreatNullAs</a></code>], or</p>
<li data-md="">
<p><var>V</var> is being returned from a <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-7">user object</a> implementation of an
attribute annotated with [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-7">TreatNullAs</a></code>],</p>
</ul>
<p>then return the <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-40">DOMString</a></code> value that represents the empty string.</p>
<li data-md="">
<p>Let <var>x</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>V</var>).</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-41">DOMString</a></code> value that represents the same sequence of code units as the one the ECMAScript <emu-val>String</emu-val> value <var>x</var> represents.</p>
</ol>
<p id="DOMString-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-15">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-42">DOMString</a></code> value to an ECMAScript
value is the <emu-val>String</emu-val> value that represents the same sequence of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-6">code units</a> that the
IDL <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-43">DOMString</a></code> represents. </p>
<h4 class="heading settled" data-level="3.2.17" id="es-ByteString"><span class="secno">3.2.17. </span><span class="content">ByteString</span><a class="self-link" href="#es-ByteString"></a></h4>
<p id="es-to-ByteString"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-16">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-11">ByteString</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>x</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>V</var>).</p>
<li data-md="">
<p>If the value of any <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">element</a> of <var>x</var> is greater than 255, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-20">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return an IDL <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-12">ByteString</a></code> value
whose length is the length of <var>x</var>, and where the value of each element is
the value of the corresponding element of <var>x</var>.</p>
</ol>
<p id="ByteString-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-16">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-13">ByteString</a></code> value to an ECMAScript
value is a <emu-val>String</emu-val> value whose length is the length of the <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-14">ByteString</a></code>,
and the value of each element of which is the value of the corresponding element
of the <code class="idl"><a data-link-type="idl" href="#idl-ByteString" id="ref-for-idl-ByteString-15">ByteString</a></code>. </p>
<h4 class="heading settled" data-level="3.2.18" id="es-USVString"><span class="secno">3.2.18. </span><span class="content">USVString</span><a class="self-link" href="#es-USVString"></a></h4>
<p id="es-to-USVString"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-17">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-11">USVString</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>string</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-18">converting</a> <var>V</var> to a <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-44">DOMString</a></code>.</p>
<li data-md="">
<p>Return an IDL <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-12">USVString</a></code> value
that is the result of <a data-link-type="dfn" href="#dfn-obtain-unicode" id="ref-for-dfn-obtain-unicode-1">converting string to a sequence of Unicode scalar values</a>.</p>
</ol>
<p id="USVString-to-es"> An IDL <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-13">USVString</a></code> value is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-17">converted</a> to an ECMAScript value by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>scalarValues</var> be the sequence of <a data-link-type="dfn" href="http://www.unicode.org/glossary/#unicode_scalar_value">Unicode scalar values</a> the <code class="idl"><a data-link-type="idl" href="#idl-USVString" id="ref-for-idl-USVString-14">USVString</a></code> represents.</p>
<li data-md="">
<p>Let <var>string</var> be the sequence of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-7">code units</a> that results from encoding <var>scalarValues</var> in UTF-16.</p>
<li data-md="">
<p>Return the <emu-val>String</emu-val> value that represents the same sequence of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-8">code units</a> as <var>string</var>.</p>
</ol>
<h4 class="heading settled" data-level="3.2.19" id="es-object"><span class="secno">3.2.19. </span><span class="content">object</span><a class="self-link" href="#es-object"></a></h4>
<p>IDL <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-10">object</a></code> values are represented by ECMAScript <emu-val>Object</emu-val> values.</p>
<p id="es-to-object"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-19">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-11">object</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-21">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-12">object</a></code> value that is a reference to the same object as <var>V</var>.</p>
</ol>
<p id="object-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-18">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-13">object</a></code> value to an ECMAScript
value is the <emu-val>Object</emu-val> value that represents a reference to the same object that the
IDL <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-14">object</a></code> represents. </p>
<h4 class="heading settled" data-level="3.2.20" id="es-interface"><span class="secno">3.2.20. </span><span class="content">Interface types</span><a class="self-link" href="#es-interface"></a></h4>
<p>IDL <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-4">interface type</a> values are represented by ECMAScript <emu-val>Object</emu-val> or <emu-val>Function</emu-val> values.</p>
<p id="es-to-interface"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-20">converted</a> to an IDL <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-5">interface type</a> value
by running the following algorithm (where <var>I</var> is the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-54">interface</a>): </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-22">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>If <var>V</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-13">platform object</a> that implements <var>I</var>, then return the IDL <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-6">interface type</a> value that represents a reference to that platform object.</p>
<li data-md="">
<p>If <var>V</var> is a <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-8">user object</a> that is considered to implement <var>I</var> according to the rules in <a href="#es-user-objects">§3.9 User objects implementing callback interfaces</a>, then return the IDL <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-7">interface type</a> value that represents a reference to that
user object, with the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#incumbent-settings-object">incumbent settings object</a> as the <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-5">callback context</a>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-23">Throw a <emu-val>TypeError</emu-val></a>.</p>
</ol>
<p id="interface-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-19">converting</a> an IDL <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-8">interface type</a> value to an ECMAScript value is the <emu-val>Object</emu-val> value that represents a reference to the same object that the IDL <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-9">interface type</a> value represents. </p>
<h4 class="heading settled" data-level="3.2.21" id="es-dictionary"><span class="secno">3.2.21. </span><span class="content">Dictionary types</span><a class="self-link" href="#es-dictionary"></a></h4>
<p>IDL <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-6">dictionary type</a> values are represented
by ECMAScript <emu-val>Object</emu-val> values. Properties on
the object (or its prototype chain) correspond to <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-30">dictionary members</a>.</p>
<p id="es-to-dictionary"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-21">converted</a> to an IDL <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-7">dictionary type</a> value
by running the following algorithm (where <var>D</var> is the <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-11">dictionary</a>): </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Undefined, Null or Object, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-24">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>If <var>V</var> is a native <emu-val>RegExp</emu-val> object, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-25">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>dict</var> be an empty dictionary value of type <var>D</var>;
every <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-31">dictionary member</a> is initially considered to be <a data-link-type="dfn" href="#dfn-present" id="ref-for-dfn-present-2">not present</a>.</p>
<li data-md="">
<p>Let <var>dictionaries</var> be a list consisting of <var>D</var> and all of <var>D</var>’s <a data-link-type="dfn" href="#dfn-inherited-dictionaries" id="ref-for-dfn-inherited-dictionaries-4">inherited dictionaries</a>,
in order from least to most derived.</p>
<li data-md="">
<p>For each dictionary <var>dictionary</var> in <var>dictionaries</var>, in order:</p>
<ol>
<li data-md="">
<p>For each dictionary member <var>member</var> declared on <var>dictionary</var>, in lexicographical order:</p>
<ol>
<li data-md="">
<p>Let <var>key</var> be the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-49">identifier</a> of <var>member</var>.</p>
<li data-md="">
<p>Let <var>value</var> be an ECMAScript value, depending on <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>):</p>
<dl class="switch">
<dt data-md="">
<p>Undefined</p>
<dt data-md="">
<p>Null</p>
<dd data-md="">
<p><var>value</var> is <emu-val>undefined</emu-val>.</p>
<dt data-md="">
<p>anything else</p>
<dd data-md="">
<p><var>value</var> is the result of calling the [[Get]] internal method of <var>V</var> passing <var>key</var> and <var>V</var> as arguments.</p>
</dl>
<li data-md="">
<p>If <var>value</var> is not <emu-val>undefined</emu-val>, then:</p>
<ol>
<li data-md="">
<p>Let <var>idlValue</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-22">converting</a> <var>value</var> to an IDL value whose type is the type <var>member</var> is declared to be of.</p>
<li data-md="">
<p>Set the dictionary member on <var>dict</var> with key name <var>key</var> to the value <var>idlValue</var>. This dictionary member is considered to be <a data-link-type="dfn" href="#dfn-present" id="ref-for-dfn-present-3">present</a>.</p>
</ol>
<li data-md="">
<p>Otherwise, if <var>value</var> is <emu-val>undefined</emu-val> but the <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-32">dictionary member</a> has a <a data-link-type="dfn" href="#dfn-dictionary-member-default-value" id="ref-for-dfn-dictionary-member-default-value-8">default value</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>idlValue</var> be the dictionary member’s default value.</p>
<li data-md="">
<p>Set the dictionary member on <var>dict</var> with key name <var>key</var> to the value <var>idlValue</var>. This dictionary member is considered to be <a data-link-type="dfn" href="#dfn-present" id="ref-for-dfn-present-4">present</a>.</p>
</ol>
<li data-md="">
<p>Otherwise, if <var>value</var> is <emu-val>undefined</emu-val> and the <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-33">dictionary member</a> is a <a data-link-type="dfn" href="#required-dictionary-member" id="ref-for-required-dictionary-member-3">required dictionary member</a>, then throw a <emu-val>TypeError</emu-val>.</p>
</ol>
</ol>
<li data-md="">
<p>Return <var>dict</var>.</p>
</ol>
<p class="note" role="note">Note: The order that <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-34">dictionary members</a> are looked
up on the ECMAScript object are not necessarily the same as the object’s property enumeration order.</p>
<p id="dictionary-to-es"> An IDL dictionary value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-20">converted</a> to an ECMAScript <emu-val>Object</emu-val> value
by running the following algorithm (where <var>D</var> is the <a data-link-type="dfn" href="#dfn-dictionary" id="ref-for-dfn-dictionary-12">dictionary</a>): </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be a new <emu-val>Object</emu-val> value created as if by the expression <code>({})</code>.</p>
<li data-md="">
<p>Let <var>dictionaries</var> be a list consisting of <var>D</var> and all of <var>D</var>’s <a data-link-type="dfn" href="#dfn-inherited-dictionaries" id="ref-for-dfn-inherited-dictionaries-5">inherited dictionaries</a>,
in order from least to most derived.</p>
<li data-md="">
<p>For each dictionary <var>dictionary</var> in <var>dictionaries</var>, in order:</p>
<ol>
<li data-md="">
<p>For each dictionary member <var>member</var> declared on <var>dictionary</var>, in lexicographical order:</p>
<ol>
<li data-md="">
<p>Let <var>key</var> be the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-50">identifier</a> of <var>member</var>.</p>
<li data-md="">
<p>If the dictionary member named <var>key</var> is <a data-link-type="dfn" href="#dfn-present" id="ref-for-dfn-present-5">present</a> in <var>V</var>, then:</p>
<ol>
<li data-md="">
<p>Let <var>idlValue</var> be the value of <var>member</var> on <var>V</var>.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-21">converting</a> <var>idlValue</var> to an ECMAScript value.</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>O</var>, <var>key</var>, <var>value</var>).</p>
</ol>
</ol>
</ol>
<li data-md="">
<p>Return <var>O</var>.</p>
</ol>
<h4 class="heading settled" data-level="3.2.22" id="es-enumeration"><span class="secno">3.2.22. </span><span class="content">Enumeration types</span><a class="self-link" href="#es-enumeration"></a></h4>
<p>IDL <a data-link-type="dfn" href="#idl-enumeration" id="ref-for-idl-enumeration-2">enumeration types</a> are represented by ECMAScript <emu-val>String</emu-val> values.</p>
<p id="es-to-enumeration"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-23">converted</a> to an IDL <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-17">enumeration type</a> value as follows (where <var>E</var> is the <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-18">enumeration</a>): </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>V</var>).</p>
<li data-md="">
<p>If <var>S</var> is not one of <var>E</var>’s <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-5">enumeration values</a>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-26">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the enumeration value of type <var>E</var> that is equal to <var>S</var>.</p>
</ol>
<p id="enumeration-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-22">converting</a> an IDL <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-19">enumeration type</a> value to an ECMAScript
value is the <emu-val>String</emu-val> value that represents the same sequence of <a data-link-type="dfn" href="#dfn-code-unit" id="ref-for-dfn-code-unit-9">code units</a> as
the <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-6">enumeration value</a>. </p>
<h4 class="heading settled" data-level="3.2.23" id="es-callback-function"><span class="secno">3.2.23. </span><span class="content">Callback function types</span><a class="self-link" href="#es-callback-function"></a></h4>
<p>IDL <a data-link-type="dfn" href="#idl-callback-function" id="ref-for-idl-callback-function-1">callback function types</a> are represented by ECMAScript <emu-val>Function</emu-val> objects, except in the [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-2">TreatNonObjectAsNull</a></code>] case,
when they can be any object.</p>
<p id="es-to-callback-function"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-24">converted</a> to an IDL <a data-link-type="dfn" href="#idl-callback-function" id="ref-for-idl-callback-function-2">callback function type</a> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>V</var>) is <emu-val>false</emu-val> and the conversion to an IDL value
is not being performed due
to <var>V</var> being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-42">attribute</a> whose type is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-16">nullable</a> <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-19">callback function</a> that is annotated with [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-3">TreatNonObjectAsNull</a></code>],
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-27">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <a data-link-type="dfn" href="#idl-callback-function" id="ref-for-idl-callback-function-3">callback function type</a> value
that represents a reference to the same object that <var>V</var> represents, with the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#incumbent-settings-object">incumbent settings object</a> as the <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-6">callback context</a>.</p>
</ol>
<p id="callback-function-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-23">converting</a> an IDL <a data-link-type="dfn" href="#idl-callback-function" id="ref-for-idl-callback-function-4">callback function type</a> value to an ECMAScript value is a reference to the same object
that the IDL <a data-link-type="dfn" href="#idl-callback-function" id="ref-for-idl-callback-function-5">callback function type</a> value represents. </p>
<h4 class="heading settled" data-level="3.2.24" id="es-nullable-type"><span class="secno">3.2.24. </span><span class="content">Nullable types — <var>T</var>?</span><a class="self-link" href="#es-nullable-type"></a></h4>
<p>IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-17">nullable type</a> values are represented
by values of either the ECMAScript type corresponding to the <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-8">inner IDL type</a>, or
the ECMAScript <emu-val>null</emu-val> value.</p>
<p id="es-to-nullable"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-25">converted</a> to an IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-18">nullable type</a> <code class="idl"><var>T</var>?</code> value (where <var>T</var> is the <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-9">inner type</a>) as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object, and
the conversion to an IDL value is being performed due
to <var>V</var> being assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-43">attribute</a> whose type is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-19">nullable</a> <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-20">callback function</a> that is annotated with [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-4">TreatNonObjectAsNull</a></code>],
then return the IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-20">nullable type</a> <code class="idl"><var>T</var>?</code> value <emu-val>null</emu-val>.</p>
<li data-md="">
<p>Otherwise, if <var>V</var> is <emu-val>null</emu-val> or <emu-val>undefined</emu-val>, then return the IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-21">nullable type</a> <code class="idl"><var>T</var>?</code> value <emu-val>null</emu-val>.</p>
<li data-md="">
<p>Otherwise, return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-26">converting</a> <var>V</var> using the rules for the <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-10">inner IDL type</a> <code class="idl">T</code>.</p>
</ol>
<p id="nullable-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-24">converting</a> an IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-22">nullable type</a> value to an ECMAScript value is: </p>
<ul>
<li data-md="">
<p>If the IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-23">nullable type</a> <code class="idl"><var>T</var>?</code> value is <emu-val>null</emu-val>,
then the ECMAScript value is <emu-val>null</emu-val>.</p>
<li data-md="">
<p>Otherwise, the ECMAScript value is the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-25">converting</a> the IDL <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-24">nullable type</a> value
to the <a data-link-type="dfn" href="#dfn-inner-type" id="ref-for-dfn-inner-type-11">inner IDL type</a> <code class="idl">T</code>.</p>
</ul>
<h4 class="heading settled" data-level="3.2.25" id="es-sequence"><span class="secno">3.2.25. </span><span class="content">Sequences — sequence<<var>T</var>></span><a class="self-link" href="#es-sequence"></a></h4>
<p>IDL <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-10">sequence<<var>T</var>></a> values are represented by
ECMAScript <emu-val>Array</emu-val> values.</p>
<p id="es-to-sequence"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-27">converted</a> to an IDL <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-11">sequence<<var>T</var>></a> value as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>If <var>V</var> is not an object, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-28">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>If <var>V</var> is a native <emu-val>RegExp</emu-val> object, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-29">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>method</var> be the result of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-getmethod">GetMethod</a>(<var>V</var>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>method</var>).</p>
<li data-md="">
<p>If <var>method</var> is <emu-val>undefined</emu-val>, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-30">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#create-sequence-from-iterable" id="ref-for-create-sequence-from-iterable-1">creating a sequence</a> from <var>V</var> and <var>method</var>.</p>
</ol>
<p id="sequence-to-es"> An IDL sequence value <var>S</var> of type <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-12">sequence<<var>T</var>></a> is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-26">converted</a> to an ECMAScript <emu-val>Array</emu-val> object as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>n</var> be the length of <var>S</var>.</p>
<li data-md="">
<p>Let <var>A</var> be a new <emu-val>Array</emu-val> object created as if by the expression <code>[]</code>.</p>
<li data-md="">
<p>Initialize <var>i</var> to be 0.</p>
<li data-md="">
<p>While <var>i</var> < <var>n</var>:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the value in <var>S</var> at index <var>i</var>.</p>
<li data-md="">
<p>Let <var>E</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-27">converting</a> <var>V</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>P</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>i</var>).</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>A</var>, <var>P</var>, <var>E</var>).</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Return <var>A</var>.</p>
</ol>
<h5 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="3.2.25.1" data-lt="Creating a sequence from an iterable" data-noexport="" id="create-sequence-from-iterable"><span class="secno">3.2.25.1. </span><span class="content">Creating a sequence from an iterable</span></h5>
<p>To create an IDL value of type <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-13">sequence<<var>T</var>></a> given an
iterable <var>iterable</var> and an iterator getter <var>method</var>, perform the following steps:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>iter</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-getiterator">GetIterator</a>(<var>iterable</var>, <var>method</var>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>iter</var>).</p>
<li data-md="">
<p>Initialize <var>i</var> to be 0.</p>
<li data-md="">
<p>Repeat</p>
<ol>
<li data-md="">
<p>Let <var>next</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iteratorstep">IteratorStep</a>(<var>iter</var>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>next</var>).</p>
<li data-md="">
<p>If <var>next</var> is <emu-val>false</emu-val>,
then return an IDL sequence value of type <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-14">sequence<<var>T</var>></a> of length <var>i</var>, where the value of the element
at index <var>j</var> is <var>S</var><sub><var>j</var></sub>.</p>
<li data-md="">
<p>Let <var>nextItem</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iteratorvalue">IteratorValue</a>(<var>next</var>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>nextItem</var>).</p>
<li data-md="">
<p>Initialize <var>S</var><sub><var>i</var></sub> to the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-28">converting</a> <var>nextItem</var> to an IDL value of type <var>T</var>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
</ol>
<div class="example" id="example-a537022f">
<a class="self-link" href="#example-a537022f"></a>
<p>The following <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-55">interface</a> defines
an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-44">attribute</a> of a sequence
type as well as an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-48">operation</a> with an argument of a sequence type.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Canvas</span> {
<span class="kt">sequence</span><<span class="kt">DOMString</span>> <span class="nv">getSupportedImageCodecs</span>();
<span class="kt">void</span> <span class="nv">drawPolygon</span>(<span class="kt">sequence</span><<span class="kt">double</span>> <span class="nv">coordinates</span>);
<span class="kt">sequence</span><<span class="kt">double</span>> <span class="nv">getLastDrawnPolygon</span>();
// ...
};
</pre>
<p>In an ECMAScript implementation of this interface, an <emu-val>Array</emu-val> object with elements of type <emu-val>String</emu-val> is used to
represent a <code class="idl">sequence<DOMString></code>, while an <emu-val>Array</emu-val> with elements of type <emu-val>Number</emu-val> represents a <code class="idl">sequence<double></code>. The <emu-val>Array</emu-val> objects are effectively passed by
value; every time the <code>getSupportedImageCodecs()</code> function is called a new <emu-val>Array</emu-val> is
returned, and whenever an <emu-val>Array</emu-val> is
passed to <code>drawPolygon</code> no reference
will be kept after the call completes.</p>
<pre class="highlight"><span class="c1">// Obtain an instance of Canvas. Assume that getSupportedImageCodecs()
</span><span class="c1">// returns a sequence with two DOMString values: "image/png" and "image/svg+xml".
</span><span class="kd">var</span> canvas <span class="o">=</span> getCanvas<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// An Array object of length 2.
</span><span class="kd">var</span> supportedImageCodecs <span class="o">=</span> canvas<span class="p">.</span>getSupportedImageCodecs<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Evaluates to "image/png".
</span>supportedImageCodecs<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">;</span>
<span class="c1">// Each time canvas.getSupportedImageCodecs() is called, it returns a
</span><span class="c1">// new Array object. Thus modifying the returned Array will not
</span><span class="c1">// affect the value returned from a subsequent call to the function.
</span>supportedImageCodecs<span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"image/jpeg"</span><span class="p">;</span>
<span class="c1">// Evaluates to "image/png".
</span>canvas<span class="p">.</span>getSupportedImageCodecs<span class="p">(</span><span class="p">)</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">;</span>
<span class="c1">// This evaluates to false, since a new Array object is returned each call.
</span>canvas<span class="p">.</span>getSupportedImageCodecs<span class="p">(</span><span class="p">)</span> <span class="o">==</span> canvas<span class="p">.</span>getSupportedImageCodecs<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// An Array of Numbers...
</span><span class="kd">var</span> a <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">50</span><span class="p">,</span> <span class="mf">62.5</span><span class="p">]</span><span class="p">;</span>
<span class="c1">// ...can be passed to a platform object expecting a sequence<double>.
</span>canvas<span class="p">.</span>drawPolygon<span class="p">(</span>a<span class="p">)</span><span class="p">;</span>
<span class="c1">// Each element will be converted to a double by first calling ToNumber().
</span><span class="c1">// So the following call is equivalent to the previous one, except that
</span><span class="c1">// "hi" will be alerted before drawPolygon() returns.
</span>a <span class="o">=</span> <span class="p">[</span><span class="kc">false</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span>
<span class="p">{</span> valueOf<span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> alert<span class="p">(</span><span class="s1">'hi'</span><span class="p">)</span><span class="p">;</span> <span class="k">return</span> <span class="mi">100</span><span class="p">;</span> <span class="p">}</span> <span class="p">}</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span>
<span class="s1">'50'</span><span class="p">,</span> <span class="k">new</span> Number<span class="p">(</span><span class="mf">62.5</span><span class="p">)</span><span class="p">]</span><span class="p">;</span>
canvas<span class="p">.</span>drawPolygon<span class="p">(</span>s<span class="p">)</span><span class="p">;</span>
<span class="c1">// Modifying an Array that was passed to drawPolygon() is guaranteed not to
</span><span class="c1">// have an effect on the Canvas, since the Array is effectively passed by value.
</span>a<span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
<span class="kd">var</span> b <span class="o">=</span> canvas<span class="p">.</span>getLastDrawnPolygon<span class="p">(</span><span class="p">)</span><span class="p">;</span>
alert<span class="p">(</span>b<span class="p">[</span><span class="mi">4</span><span class="p">]</span><span class="p">)</span><span class="p">;</span> <span class="c1">// This would alert "50".
</span></pre>
</div>
<h4 class="heading settled" data-level="3.2.26" id="es-open-dictionary"><span class="secno">3.2.26. </span><span class="content">Open dictionaries — OpenDictionary<[<var>K</var>,] <var>V</var>></span><a class="self-link" href="#es-open-dictionary"></a></h4>
<p>IDL <code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-1">OpenDictionary</a></code><<var>K</var>, <var>V</var>> values are represented by
ECMAScript <emu-val>Object</emu-val> values.</p>
<p id="es-to-open-dictionary"> An ECMAScript value <var>O</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-29">converted</a> to an IDL <code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-2">OpenDictionary</a></code><<var>K</var>, <var>V</var>></code> value as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>O</var>) is not <emu-val>Object</emu-val>, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-31">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>result</var> be a new empty instance of <code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-3">OpenDictionary</a></code><<var>K</var>, <var>V</var>></code>.</p>
<li data-md="">
<p>Let <var>keys</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">?</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-enumerableownproperties">EnumerableOwnProperties</a>(<var>O</var>, "key").</p>
<li data-md="">
<p>Repeat, for each element <var>key</var> of <var>keys</var> in <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-list-and-record-specification-type">List</a> order:</p>
<ol>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-hasownproperty">HasOwnProperty</a>(<var>O</var>, <var>key</var>) is <code>true</code>, then:</p>
<ol>
<li data-md="">
<p>Let <var>typedKey</var> be <var>key</var> <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-30">converted to an IDL value</a> of type <var>K</var>.</p>
<li data-md="">
<p>Let <var>value</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">?</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-get-o-p">Get</a>(<var>O</var>, <var>key</var>).</p>
<li data-md="">
<p>Let <var>typedValue</var> be <var>value</var> <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-31">converted to an IDL value</a> of type <var>V</var>.</p>
<li data-md="">
<p class="assertion">Assert: <var>typedKey</var> is not yet a key in <var>result</var>.</p>
<li data-md="">
<p>Append to <var>result</var> a mapping from <var>typedKey</var> to <var>typedValue</var>.</p>
</ol>
</ol>
<li data-md="">
<p>Return <var>result</var>.</p>
</ol>
<p id="open-dictionary-to-es"> An IDL <code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-4">OpenDictionary</a></code><…></code> value <var>D</var> is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-28">converted</a> to an ECMAScript value as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>result</var> be a new <emu-val>Object</emu-val> instance
created as if by the expression <code>{}</code>.</p>
<li data-md="">
<p>Repeat, for each <a data-link-type="dfn" href="#opendictionary-mappings" id="ref-for-opendictionary-mappings-1">mapping</a> (<var>key</var>, <var>value</var>) in <var>D</var>:</p>
<ol>
<li data-md="">
<p>Let <var>esKey</var> be <var>key</var> <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-29">converted to an ECMAScript value</a>.</p>
<li data-md="">
<p>Let <var>esValue</var> be <var>value</var> <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-30">converted to an ECMAScript value</a>.</p>
<li data-md="">
<p>Let <var>created</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>result</var>, <var>esKey</var>, <var>esValue</var>).</p>
<li data-md="">
<p class="assertion">Assert: <var>created</var> is <code>true</code>.</p>
</ol>
<li data-md="">
<p>Return <var>result</var>.</p>
</ol>
<div class="example" id="example-es-open-dictionary">
<a class="self-link" href="#example-es-open-dictionary"></a> Passing the ECMAScript value <code>{b: 3, a: 4}</code> to a <code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-5">OpenDictionary</a></code><DOMString, long></code> argument
would result in the IDL value:
<table class="data">
<thead>
<tr>
<th>Key
<th>Value
<tbody>
<tr>
<td><code>"b"</code>
<td><code>3</code>
<tr>
<td><code>"a"</code>
<td><code>4</code>
</table>
<p>Open dictionaries only consider <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-own-property">own</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-property-attributes">enumerable</a> properties, so given an IDL operation <code>OpenDictionary<long> identity(OpenDictionary<long> arg)</code> which
returns its argument, the following code passes its assertions:</p>
<pre class="highlight"><span class="kd">let</span> proto <span class="o">=</span> <span class="p">{</span>a<span class="o">:</span> <span class="mi">3</span><span class="p">,</span> b<span class="o">:</span> <span class="mi">4</span><span class="p">}</span><span class="p">;</span>
<span class="kd">let</span> obj <span class="o">=</span> <span class="p">{</span>__proto__<span class="o">:</span> proto<span class="p">,</span> d<span class="o">:</span> <span class="mi">5</span><span class="p">,</span> c<span class="o">:</span> <span class="mi">6</span><span class="p">}</span>
Object<span class="p">.</span>defineProperty<span class="p">(</span>obj<span class="p">,</span> <span class="s2">"e"</span><span class="p">,</span> <span class="p">{</span>value<span class="o">:</span> <span class="mi">7</span><span class="p">,</span> enumerable<span class="o">:</span> <span class="kc">false</span><span class="p">}</span><span class="p">)</span><span class="p">;</span>
<span class="kd">let</span> result <span class="o">=</span> identity<span class="p">(</span>obj<span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>result<span class="p">.</span>a <span class="o">===</span> <span class="kc">undefined</span><span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>result<span class="p">.</span>b <span class="o">===</span> <span class="kc">undefined</span><span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>result<span class="p">.</span>e <span class="o">===</span> <span class="kc">undefined</span><span class="p">)</span><span class="p">;</span>
<span class="kd">let</span> entries <span class="o">=</span> Object<span class="p">.</span>entries<span class="p">(</span>result<span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>entries<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">===</span> <span class="s2">"d"</span><span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>entries<span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="s2">"5"</span><span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>entries<span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">===</span> <span class="s2">"c"</span><span class="p">)</span><span class="p">;</span>
assert<span class="p">(</span>entries<span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="s2">"6"</span><span class="p">)</span><span class="p">;</span>
</pre>
<p>Open dictionary keys and values can be constrained, although keys can only be
constrained among the three string types. The following conversions all
throw <code class="idl"><a data-link-type="idl" href="#exceptiondef-typeerror" id="ref-for-exceptiondef-typeerror-2">TypeError</a></code>s:</p>
<table class="data">
<thead>
<tr>
<th>Value
<th>Passed to type
<tbody>
<tr>
<td><code>{"😞": 1}</code>
<td><code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-6">OpenDictionary</a></code><ByteString, long></code>
<tr>
<td><code>{"\uD83D": 1}</code>
<td><code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-7">OpenDictionary</a></code><USVString, long></code>
<tr>
<td><code>{a: {hello: "world"}}</code>
<td><code><code class="idl"><a data-link-type="idl" href="#idl-open-dictionary" id="ref-for-idl-open-dictionary-8">OpenDictionary</a></code><DOMString, long></code>
</table>
</div>
<h4 class="heading settled" data-level="3.2.27" id="es-promise"><span class="secno">3.2.27. </span><span class="content">Promise types — Promise<<var>T</var>></span><a class="self-link" href="#es-promise"></a></h4>
<p>IDL <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-3">promise type</a> values are
represented by ECMAScript <emu-val>Promise</emu-val> objects.</p>
<p id="es-to-promise"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-32">converted</a> to an IDL <a class="idl-code" data-link-type="interface" href="#idl-promise" id="ref-for-idl-promise-1">Promise<<var>T</var>></a> value as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>resolve</var> be the original value of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a>.resolve.</p>
<p class="issue" id="issue-5afa3eb0"><a class="self-link" href="#issue-5afa3eb0"></a> ECMAScript should grow a %Promise_resolve% well-known intrinsic object that can be referenced here. </p>
<li data-md="">
<p>Let <var>promise</var> be the result of calling <var>resolve</var> with <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a> as the <emu-val>this</emu-val> value and <var>V</var> as the single argument value.</p>
<li data-md="">
<p>Return the IDL <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-4">promise type</a> value that is a reference to the
same object as <var>promise</var>.</p>
</ol>
<p id="promise-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-31">converting</a> an IDL <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-5">promise type</a> value to an ECMAScript
value is the <emu-val>Promise</emu-val> value that represents a reference to the same object that the
IDL <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-6">promise type</a> represents. </p>
<p>One can <dfn data-dfn-type="dfn" data-export="" data-lt="upon settling" id="dfn-perform-steps-once-promise-is-settled">perform some steps once a promise is settled<a class="self-link" href="#dfn-perform-steps-once-promise-is-settled"></a></dfn>.
There can be one or two sets of steps to perform, covering when the promise is fulfilled, rejected, or both.
When a specification says to perform some steps once a promise is settled, the following steps
must be followed:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>promise</var> be the promise object of type <a class="idl-code" data-link-type="interface" href="#idl-promise" id="ref-for-idl-promise-2">Promise<<var>T</var>></a>.</p>
<li data-md="">
<p>Let <var>onFulfilled</var> be a new <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-1">function object</a> whose
behavior when invoked is as follows:</p>
<ol>
<li data-md="">
<p>If <var>T</var> is <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-4">void</a></code>, then:</p>
<ol>
<li data-md="">
<p>Return the result of performing any steps that were required to be run if the promise was fulfilled.</p>
</ol>
<li data-md="">
<p>Otherwise, <var>T</var> is a type other than <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-5">void</a></code>:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the first argument to <var>onFulfilled</var>.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-33">converting</a> <var>V</var> to an IDL value of type <var>T</var>.</p>
<li data-md="">
<p>If there are no steps that are required to be run if the promise was fulfilled, then
return <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>Otherwise, return the result of performing any steps that were required to be run if the promise was fulfilled,
with <var>value</var> as the promise’s value.</p>
</ol>
</ol>
<li data-md="">
<p>Let <var>onRejected</var> be a new <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-2">function object</a> whose
behavior when invoked is as follows:</p>
<ol>
<li data-md="">
<p>Let <var>R</var> be the first argument to <var>onRejected</var>.</p>
<li data-md="">
<p>Let <var>reason</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-34">converting</a> <var>R</var> to an IDL value of type <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-13">any</a></code>.</p>
<li data-md="">
<p>If there are no steps that are required to be run if the promise was rejected, then
return <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>Otherwise, return the result of performing any steps that were required to be run if the promise was rejected,
with <var>reason</var> as the rejection reason.</p>
</ol>
<li data-md="">
<p>Let <var>then</var> be the result of calling the internal [[Get]] method of <var>promise</var> with property name “then”.</p>
<li data-md="">
<p>If <var>then</var> is not <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">callable</a>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-32">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the result of calling <var>then</var> with <var>promise</var> as the <emu-val>this</emu-val> value and <var>onFulfilled</var> and <var>onRejected</var> as its two arguments.</p>
</ol>
<p class="issue" id="issue-efe8490d"><a class="self-link" href="#issue-efe8490d"></a> Include an example of how to write spec text using this term. </p>
<h4 class="heading settled" data-level="3.2.28" id="es-union"><span class="secno">3.2.28. </span><span class="content">Union types</span><a class="self-link" href="#es-union"></a></h4>
<p>IDL <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-23">union type</a> values are
represented by ECMAScript values that correspond to the union’s <a data-link-type="dfn" href="#dfn-union-member-type" id="ref-for-dfn-union-member-type-10">member types</a>.</p>
<p id="es-to-union"> To <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-35">convert an ECMAScript value</a> <var>V</var> to an IDL <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-24">union type</a> value is done as follows: </p>
<ol class="algorithm">
<li data-md="">
<p>If the <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-25">union type</a> <a data-link-type="dfn" href="#dfn-includes-a-nullable-type" id="ref-for-dfn-includes-a-nullable-type-3">includes a nullable type</a> and <var>V</var> is <emu-val>null</emu-val> or <emu-val>undefined</emu-val>,
then return the IDL value <emu-val>null</emu-val>.</p>
<li data-md="">
<p>Let <var>types</var> be the <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-9">flattened member types</a> of the <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-26">union type</a>.</p>
<li data-md="">
<p>If <var>V</var> is <emu-val>null</emu-val> or <emu-val>undefined</emu-val>, and <var>types</var> includes a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-8">dictionary type</a>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-36">converting</a> <var>V</var> to that dictionary type.</p>
<li data-md="">
<p>If <var>V</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-14">platform object</a>, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes an <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-10">interface type</a> that <var>V</var> implements, then return the IDL value that is a reference to the object <var>V</var>.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-15">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is a native <emu-val>RegExp</emu-val> object, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-4">RegExp</a></code>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-37">converting</a> <var>V</var> to <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-5">RegExp</a></code>.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-16">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-16">DOMException</a></code> platform object, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-17">DOMException</a></code> or <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-7">Error</a></code>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-38">converting</a> <var>V</var> to that type.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-17">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is a native <emu-val>Error</emu-val> object (that is, it has an [[ErrorData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>), then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-8">Error</a></code>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-39">converting</a> <var>V</var> to <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-9">Error</a></code>.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-18">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is an object with an [[ArrayBufferData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-11">ArrayBuffer</a></code>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-40">converting</a> <var>V</var> to <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-12">ArrayBuffer</a></code>.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-19">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is an object with a [[DataView]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-DataView" id="ref-for-idl-DataView-2">DataView</a></code>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-41">converting</a> <var>V</var> to <code class="idl"><a data-link-type="idl" href="#idl-DataView" id="ref-for-idl-DataView-3">DataView</a></code>.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-20">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is an object with a [[TypedArrayName]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-typed-array-type" id="ref-for-dfn-typed-array-type-2">typed array type</a> whose name is the value of <var>V</var>’s [[TypedArrayName]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-42">converting</a> <var>V</var> to that type.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-21">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>V</var>) is true, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-21">callback function</a> type, then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-43">converting</a> <var>V</var> to that callback function type.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-22">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is any kind of object except for
a native <emu-val>RegExp</emu-val> object, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-15">sequence type</a>, then</p>
<ol>
<li data-md="">
<p>Let <var>method</var> be the result of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-getmethod">GetMethod</a>(<var>V</var>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>method</var>).</p>
<li data-md="">
<p>If <var>method</var> is not <emu-val>undefined</emu-val>,
return the result of <a data-link-type="dfn" href="#create-sequence-from-iterable" id="ref-for-create-sequence-from-iterable-2">creating a sequence</a> of that type from <var>V</var> and <var>method</var>.</p>
</ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-frozen-array-type" id="ref-for-dfn-frozen-array-type-3">frozen array type</a>, then</p>
<ol>
<li data-md="">
<p>Let <var>method</var> be the result of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-getmethod">GetMethod</a>(<var>V</var>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>method</var>).</p>
<li data-md="">
<p>If <var>method</var> is not <emu-val>undefined</emu-val>,
return the result of <a data-link-type="dfn" href="#create-frozen-array-from-iterable" id="ref-for-create-frozen-array-from-iterable-1">creating a frozen array of that type from V and method</a>.</p>
</ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-9">dictionary type</a>, then return the
result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-44">converting</a> <var>V</var> to that dictionary type.</p>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-17">callback interface</a> type, then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-45">converting</a> <var>V</var> to that interface type.</p>
<li data-md="">
<p>If <var>types</var> includes <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-23">object</a></code>, then return the IDL value
that is a reference to the object <var>V</var>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is a <emu-val>Boolean</emu-val> value, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes a <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-15">boolean</a></code>,
then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-46">converting</a> <var>V</var> to <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-16">boolean</a></code>.</p>
</ol>
<li data-md="">
<p>If <var>V</var> is a <emu-val>Number</emu-val> value, then:</p>
<ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-2">numeric type</a>,
then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-47">converting</a> <var>V</var> to that <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-3">numeric type</a>.</p>
</ol>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-string-type" id="ref-for-dfn-string-type-2">string type</a>,
then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-48">converting</a> <var>V</var> to that type.</p>
<li data-md="">
<p>If <var>types</var> includes a <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-4">numeric type</a>,
then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-49">converting</a> <var>V</var> to that <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-5">numeric type</a>.</p>
<li data-md="">
<p>If <var>types</var> includes a <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-17">boolean</a></code>,
then return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-50">converting</a> <var>V</var> to <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-18">boolean</a></code>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-33">Throw a <emu-val>TypeError</emu-val></a>.</p>
</ol>
<p id="union-to-es"> An IDL union type value is <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-32">converted to an ECMAScript value</a> as follows. If the value is an <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-24">object</a></code> reference to a special object that represents an ECMAScript <emu-val>undefined</emu-val> value, then it is converted to the ECMAScript <emu-val>undefined</emu-val> value. Otherwise,
the rules for converting the <a data-link-type="dfn" href="#dfn-specific-type" id="ref-for-dfn-specific-type-5">specific type</a> of the IDL union type value as described in this section (<a href="#es-type-mapping">§3.2 ECMAScript type mapping</a>). </p>
<h4 class="heading settled" data-level="3.2.29" id="es-RegExp"><span class="secno">3.2.29. </span><span class="content">RegExp</span><a class="self-link" href="#es-RegExp"></a></h4>
<p>IDL <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-6">RegExp</a></code> values are represented by
ECMAScript <emu-val>RegExp</emu-val> objects.</p>
<p id="es-to-RegExp"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-51">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-7">RegExp</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object,
or <var>V</var> is not a native <emu-val>RegExp</emu-val> object,
then set <var>V</var> to be a newly created <emu-val>RegExp</emu-val> object created as if by the
expression <code>new RegExp(<var>V</var>)</code>, where <code>RegExp</code> is the standard built-in constructor with that name
from the <a data-link-type="dfn" href="#dfn-current-global-environment" id="ref-for-dfn-current-global-environment-1">current global environment</a>.</p>
<p class="note" role="note">Note: Note that this can result in an exception being thrown, if <var>V</var>, when converted to a string,
does not have valid regular expression syntax.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-8">RegExp</a></code> value that is a reference to the same object as <var>V</var>.</p>
</ol>
<p id="RegExp-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-33">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-9">RegExp</a></code> value to an ECMAScript
value is the <emu-val>RegExp</emu-val> value that represents a reference to the same object that the
IDL <code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-10">RegExp</a></code> represents. </p>
<h4 class="heading settled" data-level="3.2.30" id="es-Error"><span class="secno">3.2.30. </span><span class="content">Error</span><a class="self-link" href="#es-Error"></a></h4>
<p>IDL <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-10">Error</a></code> values are represented
by native ECMAScript <emu-val>Error</emu-val> objects and
platform objects for <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-18">DOMExceptions</a></code>.</p>
<p id="es-to-Error"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-52">converted</a> to an IDL <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-11">Error</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object,
or <var>V</var> does not have an [[ErrorData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-34">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-12">Error</a></code> value that is a reference to the same object as <var>V</var>.</p>
</ol>
<p id="Error-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-34">converting</a> an IDL <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-13">Error</a></code> value to an ECMAScript
value is the <emu-val>Error</emu-val> value that represents a reference to the same object that the
IDL <code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-14">Error</a></code> represents. </p>
<h4 class="heading settled" data-level="3.2.31" id="es-DOMException"><span class="secno">3.2.31. </span><span class="content">DOMException</span><a class="self-link" href="#es-DOMException"></a></h4>
<p>IDL <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-19">DOMException</a></code> values are represented
by platform objects for <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-20">DOMExceptions</a></code>.</p>
<p id="es-to-DOMException"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-53">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-21">DOMException</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object,
or <var>V</var> is not a platform object that represents a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-22">DOMException</a></code>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-35">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-23">DOMException</a></code> value that is a reference to the same object as <var>V</var>.</p>
</ol>
<p id="DOMException-to-es"> The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-35">converting</a> an IDL <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-24">DOMException</a></code> value to an ECMAScript
value is the <emu-val>Object</emu-val> value that represents a reference to the same object that the
IDL <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-25">DOMException</a></code> represents. </p>
<h4 class="heading settled" data-level="3.2.32" id="es-buffer-source-types"><span class="secno">3.2.32. </span><span class="content">Buffer source types</span><a class="self-link" href="#es-buffer-source-types"></a></h4>
<p>Values of the IDL <a data-link-type="dfn" href="#dfn-buffer-source-type" id="ref-for-dfn-buffer-source-type-2">buffer source types</a> are represented by objects of the corresponding ECMAScript class.</p>
<p id="es-to-buffer-source"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-54">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-13">ArrayBuffer</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object,
or <var>V</var> does not have an [[ArrayBufferData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>,
or <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isdetachedbuffer">IsDetachedBuffer</a>(<var>V</var>) is true,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-36">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-14">ArrayBuffer</a></code> value that is a reference to the same object as <var>V</var>.</p>
</ol>
<p id="buffer-source-to-es"> An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-55">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-DataView" id="ref-for-idl-DataView-4">DataView</a></code> value
by running the following algorithm: </p>
<ol class="algorithm">
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object,
or <var>V</var> does not have a [[DataView]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-37">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL <code class="idl"><a data-link-type="idl" href="#idl-DataView" id="ref-for-idl-DataView-5">DataView</a></code> value that is a reference to the same object as <var>V</var>.</p>
</ol>
<p>An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-56">converted</a> to an IDL <code class="idl"><a data-link-type="idl" href="#idl-Int8Array" id="ref-for-idl-Int8Array-2">Int8Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Int16Array" id="ref-for-idl-Int16Array-2">Int16Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Int32Array" id="ref-for-idl-Int32Array-2">Int32Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint8Array" id="ref-for-idl-Uint8Array-3">Uint8Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint16Array" id="ref-for-idl-Uint16Array-2">Uint16Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint32Array" id="ref-for-idl-Uint32Array-2">Uint32Array</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Uint8ClampedArray" id="ref-for-idl-Uint8ClampedArray-2">Uint8ClampedArray</a></code>, <code class="idl"><a data-link-type="idl" href="#idl-Float32Array" id="ref-for-idl-Float32Array-2">Float32Array</a></code> or <code class="idl"><a data-link-type="idl" href="#idl-Float64Array" id="ref-for-idl-Float64Array-2">Float64Array</a></code> value
by running the following algorithm:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>T</var> be the IDL type <var>V</var> is being converted to.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>V</var>) is not Object,
or <var>V</var> does not have a [[TypedArrayName]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> with a value equal to the name of <var>T</var>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-38">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the IDL value of type <var>T</var> that is a reference to the same object as <var>V</var>.</p>
</ol>
<p>The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-36">converting</a> an IDL value of any <a data-link-type="dfn" href="#dfn-buffer-source-type" id="ref-for-dfn-buffer-source-type-3">buffer source type</a> to an ECMAScript value is the <emu-val>Object</emu-val> value that represents
a reference to the same object that the IDL value represents.</p>
<p>When <a data-link-type="dfn" href="#dfn-get-buffer-source-reference" id="ref-for-dfn-get-buffer-source-reference-2">getting a reference to</a> or <a data-link-type="dfn" href="#dfn-get-buffer-source-copy" id="ref-for-dfn-get-buffer-source-copy-2">getting a copy of the bytes held by a buffer source</a> that is an ECMAScript <emu-val>ArrayBuffer</emu-val>, <emu-val>DataView</emu-val> or typed array object, these steps must be followed:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the ECMAScript object that is the buffer source.</p>
<li data-md="">
<p>Initialize <var>arrayBuffer</var> to <var>O</var>.</p>
<li data-md="">
<p>Initialize <var>offset</var> to 0.</p>
<li data-md="">
<p>Initialize <var>length</var> to 0.</p>
<li data-md="">
<p>If <var>O</var> has a [[ViewedArrayBuffer]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, then:</p>
<ol>
<li data-md="">
<p>Set <var>arrayBuffer</var> to the value of <var>O</var>’s [[ViewedArrayBuffer]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>If <var>arrayBuffer</var> is <emu-val>undefined</emu-val>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-39">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Set <var>offset</var> to the value of <var>O</var>’s [[ByteOffset]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Set <var>length</var> to the value of <var>O</var>’s [[ByteLength]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
</ol>
<li data-md="">
<p>Otherwise, set <var>length</var> to the value of <var>O</var>’s [[ArrayBufferByteLength]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isdetachedbuffer">IsDetachedBuffer</a>(<var>O</var>), then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-40">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>data</var> be the value of <var>O</var>’s [[ArrayBufferData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Return a reference to or copy of (as required) the <var>length</var> bytes in <var>data</var> starting at byte offset <var>offset</var>.</p>
</ol>
<p>To <a data-link-type="dfn" href="#dfn-detach" id="ref-for-dfn-detach-2">detach</a> an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-15">ArrayBuffer</a></code>,
these steps must be followed:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the ECMAScript object that is the <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-16">ArrayBuffer</a></code>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-detacharraybuffer">DetachArrayBuffer</a>(<var>O</var>).</p>
</ol>
<h4 class="heading settled" data-level="3.2.33" id="es-frozen-array"><span class="secno">3.2.33. </span><span class="content">Frozen arrays — FrozenArray<<var>T</var>></span><a class="self-link" href="#es-frozen-array"></a></h4>
<p>Values of frozen array types are represented by frozen ECMAScript <emu-val>Array</emu-val> object references.</p>
<p>An ECMAScript value <var>V</var> is <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-57">converted</a> to an IDL <a class="idl-code" data-link-type="interface" href="#idl-frozen-array" id="ref-for-idl-frozen-array-2">FrozenArray<<var>T</var>></a> value
by running the following algorithm:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>values</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-58">converting</a> <var>V</var> to IDL type <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-16">sequence<<var>T</var>></a>.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-create-frozen-array" id="ref-for-dfn-create-frozen-array-1">creating a frozen array</a> from <var>values</var>.</p>
</ol>
<p>To <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-create-frozen-array">create a frozen array</dfn> from a sequence
of values of type <var>T</var>, follow these steps:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>array</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-37">converting</a> the sequence of values to an ECMAScript value.</p>
<li data-md="">
<p>Perform <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-setintegritylevel">SetIntegrityLevel</a>(<var>array</var>, <code>"frozen"</code>).</p>
<li data-md="">
<p>Return <var>array</var>.</p>
</ol>
<p>The result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-38">converting</a> an IDL <a class="idl-code" data-link-type="interface" href="#idl-frozen-array" id="ref-for-idl-frozen-array-3">FrozenArray<<var>T</var>></a> value to an ECMAScript
value is the <emu-val>Object</emu-val> value that represents a reference
to the same object that the IDL <a class="idl-code" data-link-type="interface" href="#idl-frozen-array" id="ref-for-idl-frozen-array-4">FrozenArray<<var>T</var>></a> represents.</p>
<h5 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="3.2.33.1" data-lt="Creating a frozen array from an iterable" data-noexport="" id="create-frozen-array-from-iterable"><span class="secno">3.2.33.1. </span><span class="content">Creating a frozen array from an iterable</span></h5>
<p>To create an IDL value of type <a class="idl-code" data-link-type="interface" href="#idl-frozen-array" id="ref-for-idl-frozen-array-5">FrozenArray<<var>T</var>></a> given an
iterable <var>iterable</var> and an iterator getter <var>method</var>, perform the following steps:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>values</var> be the result of <a data-link-type="dfn" href="#create-sequence-from-iterable" id="ref-for-create-sequence-from-iterable-3">creating a sequence</a> of type <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-17">sequence<<var>T</var>></a> from <var>iterable</var> and <var>method</var>.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-create-frozen-array" id="ref-for-dfn-create-frozen-array-2">creating a frozen array</a> from <var>values</var>.</p>
</ol>
<h3 class="heading settled" data-level="3.3" id="es-extended-attributes"><span class="secno">3.3. </span><span class="content">ECMAScript-specific extended attributes</span><a class="self-link" href="#es-extended-attributes"></a></h3>
<p>This section defines a number of <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-38">extended attributes</a> whose presence affects only the ECMAScript binding.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.1" data-lt="Clamp" id="Clamp"><span class="secno">3.3.1. </span><span class="content">[Clamp]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-28">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-39">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-49">operation</a> argument,
writable <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-45">attribute</a> or <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-35">dictionary member</a> whose type is one of the <a data-link-type="dfn" href="#dfn-integer-type" id="ref-for-dfn-integer-type-4">integer types</a>,
it indicates that when an ECMAScript <emu-val>Number</emu-val> is
converted to the IDL type, out of range values will be clamped to the range
of valid values, rather than using the operators that use a modulo operation
(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toint32">ToInt32</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>, etc.).</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-29">Clamp</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-1">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-30">Clamp</a></code>] extended attribute
must not appear on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-4">read only</a> attribute, or an attribute, operation argument or dictionary member
that is not of an integer type. It also must not
be used in conjunction with the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-28">EnforceRange</a></code>]
extended attribute.</p>
<p>See the rules for converting ECMAScript values to the various IDL integer
types in <a href="#es-type-mapping">§3.2 ECMAScript type mapping</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-31">Clamp</a></code>] entails.</p>
<div class="example" id="example-4bf748b5">
<a class="self-link" href="#example-4bf748b5"></a>
<p>In the following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-34">IDL fragment</a>,
two <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-50">operations</a> are declared that
take three <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-13">octet</a></code> arguments; one uses
the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-32">Clamp</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-40">extended attribute</a> on all three arguments, while the other does not:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">GraphicsContext</span> {
<span class="kt">void</span> <span class="nv">setColor</span>(<span class="kt">octet</span> <span class="nv">red</span>, <span class="kt">octet</span> <span class="nv">green</span>, <span class="kt">octet</span> <span class="nv">blue</span>);
<span class="kt">void</span> <span class="nv">setColorClamped</span>([<span class="nv">Clamp</span>] <span class="kt">octet</span> <span class="nv">red</span>, [<span class="nv">Clamp</span>] <span class="kt">octet</span> <span class="nv">green</span>, [<span class="nv">Clamp</span>] <span class="kt">octet</span> <span class="nv">blue</span>);
};
</pre>
<p>In an ECMAScript implementation of the IDL, a call to setColorClamped with <emu-val>Number</emu-val> values that are out of range for an <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-14">octet</a></code> are clamped to the range [0, 255].</p>
<pre class="highlight"><span class="c1">// Get an instance of GraphicsContext.
</span><span class="kd">var</span> context <span class="o">=</span> getGraphicsContext<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Calling the non-[Clamp] version uses ToUint8 to coerce the Numbers to octets.
</span><span class="c1">// This is equivalent to calling setColor(255, 255, 1).
</span>context<span class="p">.</span>setColor<span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">257</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Call setColorClamped with some out of range values.
</span><span class="c1">// This is equivalent to calling setColorClamped(0, 255, 255).
</span>context<span class="p">.</span>setColorClamped<span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">257</span><span class="p">)</span><span class="p">;</span>
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.2" data-lt="Constructor" id="Constructor"><span class="secno">3.3.2. </span><span class="content">[Constructor]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-11">Constructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-41">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-56">interface</a>, it indicates that
the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-3">interface object</a> for this interface
will have an [[Construct]] internal method,
allowing objects implementing the interface to be constructed.</p>
<p>Multiple [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-12">Constructor</a></code>] extended
attributes may appear on a given interface.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-13">Constructor</a></code>]
extended attribute must either <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-2">take no arguments</a> or <a data-link-type="dfn" href="#dfn-xattr-argument-list" id="ref-for-dfn-xattr-argument-list-2">take an argument list</a>.
The bare form, <code>[Constructor]</code>, has the same meaning as
using an empty argument list, <code>[Constructor()]</code>. For each
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-14">Constructor</a></code>] extended attribute
on the interface, there will be a way to construct an object that implements
the interface by passing the specified arguments.</p>
<p>The prose definition of a constructor must
either return an IDL value of a type corresponding to the interface
the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-15">Constructor</a></code>]
extended attribute appears on, or throw an exception.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-16">Constructor</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-3">NoInterfaceObject</a></code>]
extended attributes must not be specified on the same interface.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-17">Constructor</a></code>] extended attribute
must not be used on a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-18">callback interface</a>.</p>
<p>See <a href="#es-interface-call">§3.6.1.1 Interface object [[Call]] method</a> for details on how a constructor
for an interface is to be implemented.</p>
<div class="example" id="example-595d0762">
<a class="self-link" href="#example-595d0762"></a>
<p>The following IDL defines two interfaces. The second has the
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-18">Constructor</a></code>] extended
attribute, while the first does not.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">NodeList</span> {
<span class="n">Node</span> <span class="nv">item</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>);
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">length</span>;
};
[<span class="nv">Constructor</span>,
<span class="nv">Constructor</span>(<span class="kt">double</span> <span class="nv">radius</span>)]
<span class="kt">interface</span> <span class="nv">Circle</span> {
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">r</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">cx</span>;
<span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">cy</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">circumference</span>;
};
</pre>
<p>An ECMAScript implementation supporting these interfaces would
have a [[Construct]] property on the <code class="idl">Circle</code> interface object which would
return a new object that implements the interface. It would take
either zero or one argument. The <code class="idl">NodeList</code> interface object would not
have a [[Construct]] property.</p>
<pre class="highlight"><span class="kd">var</span> x <span class="o">=</span> <span class="k">new</span> Circle<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// The uses the zero-argument constructor to create a
</span> <span class="c1">// reference to a platform object that implements the
</span> <span class="c1">// Circle interface.
</span>
<span class="kd">var</span> y <span class="o">=</span> <span class="k">new</span> Circle<span class="p">(</span><span class="mf">1.25</span><span class="p">)</span><span class="p">;</span> <span class="c1">// This also creates a Circle object, this time using
</span> <span class="c1">// the one-argument constructor.
</span>
<span class="kd">var</span> z <span class="o">=</span> <span class="k">new</span> NodeList<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// This would throw a TypeError, since no
</span> <span class="c1">// [Constructor] is declared.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.3" data-lt="EnforceRange" id="EnforceRange"><span class="secno">3.3.3. </span><span class="content">[EnforceRange]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-29">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-42">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-51">operation</a> argument,
writable <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-4">regular attribute</a> or <a data-link-type="dfn" href="#dfn-dictionary-member" id="ref-for-dfn-dictionary-member-36">dictionary member</a> whose type is one of the <a data-link-type="dfn" href="#dfn-integer-type" id="ref-for-dfn-integer-type-5">integer types</a>,
it indicates that when an ECMAScript <emu-val>Number</emu-val> is
converted to the IDL type, out of range values will cause an exception to
be thrown, rather than converted to being a valid value using the operators that use a modulo operation
(<a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toint32">ToInt32</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>, etc.). The <emu-val>Number</emu-val> will be rounded towards zero before being checked against its range.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-30">EnforceRange</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-3">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-31">EnforceRange</a></code>] extended attribute
must not appear on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-5">read only</a> attribute, a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-6">static attribute</a>,
or an attribute, operation argument or dictionary member
that is not of an integer type. It also must not
be used in conjunction with the [<code class="idl"><a data-link-type="idl" href="#Clamp" id="ref-for-Clamp-33">Clamp</a></code>]
extended attribute.</p>
<p>See the rules for converting ECMAScript values to the various IDL integer
types in <a href="#es-type-mapping">§3.2 ECMAScript type mapping</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-32">EnforceRange</a></code>] entails.</p>
<div class="example" id="example-4776c68b">
<a class="self-link" href="#example-4776c68b"></a>
<p>In the following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-35">IDL fragment</a>,
two <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-52">operations</a> are declared that
take three <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-15">octet</a></code> arguments; one uses
the [<code class="idl"><a data-link-type="idl" href="#EnforceRange" id="ref-for-EnforceRange-33">EnforceRange</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-43">extended attribute</a> on all three arguments, while the other does not:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">GraphicsContext</span> {
<span class="kt">void</span> <span class="nv">setColor</span>(<span class="kt">octet</span> <span class="nv">red</span>, <span class="kt">octet</span> <span class="nv">green</span>, <span class="kt">octet</span> <span class="nv">blue</span>);
<span class="kt">void</span> <span class="nv">setColorEnforcedRange</span>([<span class="nv">EnforceRange</span>] <span class="kt">octet</span> <span class="nv">red</span>, [<span class="nv">EnforceRange</span>] <span class="kt">octet</span> <span class="nv">green</span>, [<span class="nv">EnforceRange</span>] <span class="kt">octet</span> <span class="nv">blue</span>);
};
</pre>
<p>In an ECMAScript implementation of the IDL, a call to setColorEnforcedRange with <emu-val>Number</emu-val> values that are out of range for an <code class="idl"><a data-link-type="idl" href="#idl-octet" id="ref-for-idl-octet-16">octet</a></code> will result in an exception being
thrown.</p>
<pre class="highlight"><span class="c1">// Get an instance of GraphicsContext.
</span><span class="kd">var</span> context <span class="o">=</span> getGraphicsContext<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// Calling the non-[EnforceRange] version uses ToUint8 to coerce the Numbers to octets.
</span><span class="c1">// This is equivalent to calling setColor(255, 255, 1).
</span>context<span class="p">.</span>setColor<span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">257</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// When setColorEnforcedRange is called, Numbers are rounded towards zero.
</span><span class="c1">// This is equivalent to calling setColor(0, 255, 255).
</span>context<span class="p">.</span>setColorEnforcedRange<span class="p">(</span><span class="o">-</span><span class="mf">0.9</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mf">255.2</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// The following will cause a TypeError to be thrown, since even after
</span><span class="c1">// rounding the first and third argument values are out of range.
</span>context<span class="p">.</span>setColorEnforcedRange<span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">256</span><span class="p">)</span><span class="p">;</span>
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.4" data-lt="Exposed" id="Exposed"><span class="secno">3.3.4. </span><span class="content">[Exposed]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-9">Exposed</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-44">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-57">interface</a>, <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-8">partial interface</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-6">namespace</a>, <a data-link-type="dfn" href="#dfn-partial-namespace" id="ref-for-dfn-partial-namespace-3">partial namespace</a>, or
an individual <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-11">interface member</a> or <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-3">namespace member</a>,
it indicates that the construct is exposed
on a particular set of global interfaces, rather than the default of
being exposed only on the <a data-link-type="dfn" href="#dfn-primary-global-interface" id="ref-for-dfn-primary-global-interface-1">primary global interface</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-10">Exposed</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-45">extended attribute</a> must either <a data-link-type="dfn" href="#dfn-xattr-identifier" id="ref-for-dfn-xattr-identifier-1">take an identifier</a> or <a data-link-type="dfn" href="#dfn-xattr-identifier-list" id="ref-for-dfn-xattr-identifier-list-1">take an identifier list</a>.
Each of the identifiers mentioned must be
a <a data-link-type="dfn" href="#dfn-global-name" id="ref-for-dfn-global-name-1">global name</a>.</p>
<p>Every construct that the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-11">Exposed</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-46">extended attribute</a> can be specified on has an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-exposure-set">exposure set</dfn>,
which is a set of <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-58">interfaces</a> defining which global environments the construct can be used in.
The <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-1">exposure set</a> for a given construct is defined as follows:</p>
<ul>
<li data-md="">
<p>If the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-12">Exposed</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-47">extended attribute</a> is specified on the construct, then the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-2">exposure set</a> is the set of all interfaces that have a <a data-link-type="dfn" href="#dfn-global-name" id="ref-for-dfn-global-name-2">global name</a> that is listed in the extended attribute’s argument.</p>
<li data-md="">
<p>If the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-13">Exposed</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-48">extended attribute</a> does not appear on a construct, then its <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-3">exposure set</a> is defined
implicitly, depending on the type of construct:</p>
<dl class="switch">
<dt data-md="">
<p>interface</p>
<dt data-md="">
<p>namespace</p>
<dd data-md="">
<p>The <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-4">exposure set</a> of the
interface or namespace only contains the <a data-link-type="dfn" href="#dfn-primary-global-interface" id="ref-for-dfn-primary-global-interface-2">primary global interface</a>.</p>
<dt data-md="">
<p>partial interface</p>
<dt data-md="">
<p>partial namespace</p>
<dd data-md="">
<p>The <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-5">exposure set</a> of the partial
interface or namespace is the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-6">exposure set</a> of the original interface or namespace definition.</p>
<dt data-md="">
<p>interface member</p>
<dd data-md="">
<p>The <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-7">exposure set</a> of the interface member
is the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-8">exposure set</a> of the interface or
partial interface the member is declared on.</p>
<dt data-md="">
<p>namespace member</p>
<dd data-md="">
<p>The <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-9">exposure set</a> of the
namespace member is the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-10">exposure set</a> of the namespace or partial namespace the member is declared on.</p>
</dl>
</ul>
<p>If [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-14">Exposed</a></code>] appears on an <a data-link-type="dfn" href="#dfn-overloaded" id="ref-for-dfn-overloaded-2">overloaded</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-53">operation</a>,
then it must appear identically on all overloads.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-15">Exposed</a></code>] extended attribute
must not be specified on both an interface
member and a partial interface definition the interface member is declared on.
Similarly, the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-16">Exposed</a></code>] extended attribute
must not be specified on both a namespace
member and a partial namespace definition the namespace member is declared on.</p>
<p>If [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-17">Exposed</a></code>] appears an interface member, then
the interface member’s <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-11">exposure set</a> must be a subset of the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-12">exposure set</a> of the interface or partial interface it’s a
member of. Similarly, if [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-18">Exposed</a></code>] appears on a
namespace member, then the namespace member’s <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-13">exposure set</a> must be a
subset of the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-14">exposure set</a> of the
namespace or partial namespace it’s a member of.</p>
<p>An interface’s <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-15">exposure set</a> must be a subset of the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-16">exposure set</a> of all
of the interface’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-13">consequential interfaces</a>.</p>
<p>If an interface <var>X</var> <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-9">inherits</a> from another interface <var>Y</var> then the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-17">exposure set</a> of <var>X</var> must be a subset of the <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-18">exposure set</a> of <var>Y</var>.</p>
<p>An <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-59">interface</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-7">namespace</a>, <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-12">interface member</a>, or <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-4">namespace member</a> is <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-exposed">exposed</dfn> in a given ECMAScript global environment if the
ECMAScript global object implements an interface that is in the construct’s <a data-link-type="dfn" href="#dfn-exposure-set" id="ref-for-dfn-exposure-set-19">exposure set</a>, and either:</p>
<ul>
<li data-md="">
<p>the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#relevant-settings-object">relevant settings object</a> for the ECMAScript global object is a <a data-link-type="dfn" href="https://w3c.github.io/webappsec-secure-contexts/#secure-context">secure context</a>; or</p>
<li data-md="">
<p>the construct is not <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-1">available only in secure contexts</a>.</p>
</ul>
<p class="note" role="note">Note: Since it is not possible for the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#relevant-settings-object">relevant settings object</a> for an ECMAScript global object to change whether it is a <a data-link-type="dfn" href="https://w3c.github.io/webappsec-secure-contexts/#secure-context">secure context</a> or not over time, an implementation’s
decision to create properties for an interface or interface member
can be made once, at the time the <a data-link-type="dfn" href="#dfn-initial-object" id="ref-for-dfn-initial-object-3">initial objects</a> are created.</p>
<p>See <a href="#es-interfaces">§3.6 Interfaces</a>, <a href="#es-constants">§3.6.5 Constants</a>, <a href="#es-attributes">§3.6.6 Attributes</a>, <a href="#es-operations">§3.6.7 Operations</a> and <a href="#es-iterators">§3.6.8 Common iterator behavior</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-19">Exposed</a></code>] entails.</p>
<div class="example" id="example-eafd180b">
<a class="self-link" href="#example-eafd180b"></a>
<p>[<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-20">Exposed</a></code>]
is intended to be used to control whether interfaces, namespaces, or individual
interface or namespace members are available for use only in workers, only in the <code class="idl">Window</code>, or in both.</p>
<p>The following IDL fragment shows how that might be achieved:</p>
<pre class="highlight">[<span class="nv">PrimaryGlobal</span>]
<span class="kt">interface</span> <span class="nv">Window</span> {
// ...
};
// By using the same identifier Worker for both SharedWorkerGlobalScope
// and DedicatedWorkerGlobalScope, both can be addressed in an [Exposed]
// extended attribute at once.
[<span class="nv">Global</span>=<span class="n">Worker</span>]
<span class="kt">interface</span> <span class="nv">SharedWorkerGlobalScope</span> : <span class="n">WorkerGlobalScope</span> {
// ...
};
[<span class="nv">Global</span>=<span class="n">Worker</span>]
<span class="kt">interface</span> <span class="nv">DedicatedWorkerGlobalScope</span> : <span class="n">WorkerGlobalScope</span> {
// ...
};
// Dimensions is available for use in workers and on the main thread.
[<span class="nv">Exposed</span>=(<span class="n">Window</span>,<span class="n">Worker</span>), <span class="nv">Constructor</span>(<span class="kt">double</span> <span class="nv">width</span>, <span class="kt">double</span> <span class="nv">height</span>)]
<span class="kt">interface</span> <span class="nv">Dimensions</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">width</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">double</span> <span class="nv">height</span>;
};
// WorkerNavigator is only available in workers. Evaluating WorkerNavigator
// in the global scope of a worker would give you its interface object, while
// doing so on the main thread will give you a ReferenceError.
[<span class="nv">Exposed</span>=<span class="n">Worker</span>]
<span class="kt">interface</span> <span class="nv">WorkerNavigator</span> {
// ...
};
// Node is only available on the main thread. Evaluating Node
// in the global scope of a worker would give you a ReferenceError.
<span class="kt">interface</span> <span class="nv">Node</span> {
// ...
};
// MathUtils is available for use in workers and on the main thread.
[<span class="nv">Exposed</span>=(<span class="n">Window</span>,<span class="n">Worker</span>)]
<span class="kt">namespace</span> <span class="nv">MathUtils</span> {
<span class="kt">double</span> <span class="nv">someComplicatedFunction</span>(<span class="kt">double</span> <span class="nv">x</span>, <span class="kt">double</span> <span class="nv">y</span>);
};
// WorkerUtils is only available in workers. Evaluating WorkerUtils
// in the global scope of a worker would give you its namespace object, while
// doing so on the main thread will give you a ReferenceError.
[<span class="nv">Exposed</span>=<span class="n">Worker</span>]
<span class="kt">namespace</span> <span class="nv">WorkerUtils</span> {
<span class="kt">void</span> <span class="nv">setPriority</span>(<span class="kt">double</span> <span class="nv">x</span>);
};
// NodeUtils is only available in the main thread. Evaluating NodeUtils
// in the global scope of a worker would give you a ReferenceError.
<span class="kt">namespace</span> <span class="nv">NodeUtils</span> {
<span class="kt">DOMString</span> <span class="nv">getAllText</span>(<span class="n">Node</span> <span class="nv">node</span>);
};
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.5" data-lt="Global|PrimaryGlobal" dfn="" id="Global"><span class="secno">3.3.5. </span><span class="content">[Global] and [PrimaryGlobal]</span><span id="PrimaryGlobal"></span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-5">Global</a></code>]
or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-6">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-49">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-60">interface</a>,
it indicates that objects implementing this interface can
be used as the global object in an ECMAScript environment,
and that the structure of the prototype chain and how
properties corresponding to <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-13">interface members</a> will be reflected on the prototype objects will be different from other
interfaces. Specifically:</p>
<ol>
<li data-md="">
<p>Any <a data-link-type="dfn" href="#idl-named-properties" id="ref-for-idl-named-properties-2">named properties</a> will be exposed on an object in the prototype chain – the <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-3">named properties object</a> –
rather than on the object itself.</p>
<li data-md="">
<p><a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-14">Interface members</a> from the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-61">interface</a> (or <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-14">consequential interfaces</a>)
will correspond to properties on the object itself rather than on <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-4">interface prototype objects</a>.</p>
</ol>
<div class="note" role="note">
<p>Placing named properties on an object in the prototype chain
is done so that variable declarations and bareword assignments
will shadow the named property with a property on the global
object itself.</p>
<p>Placing properties corresponding to interface members on
the object itself will mean that common feature detection
methods like the following will work:</p>
<pre class="highlight"><span class="kd">var</span> indexedDB <span class="o">=</span> window<span class="p">.</span>indexedDB <span class="o">||</span> window<span class="p">.</span>webkitIndexedDB <span class="o">||</span>
window<span class="p">.</span>mozIndexedDB <span class="o">||</span> window<span class="p">.</span>msIndexedDB<span class="p">;</span>
<span class="kd">var</span> requestAnimationFrame <span class="o">=</span> window<span class="p">.</span>requestAnimationFrame <span class="o">||</span>
window<span class="p">.</span>mozRequestAnimationFrame <span class="o">||</span> <span class="p">...</span><span class="p">;</span>
</pre>
<p>Because of the way variable declarations are handled in
ECMAScript, the code above would result in the <code>window.indexedDB</code> and <code>window.requestAnimationFrame</code> evaluating
to <code>undefined</code>, as the shadowing variable
property would already have been created before the
assignment is evaluated.</p>
</div>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-7">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-8">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-50">extended attributes</a> is used on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-62">interface</a>, then:</p>
<ul>
<li data-md="">
<p>The interface must not define a <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-3">named property setter</a>.</p>
<li data-md="">
<p>The interface must not also be declared with the [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-3">OverrideBuiltins</a></code>]
extended attribute.</p>
<li data-md="">
<p>The interface must not <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-10">inherit</a> from another interface with the
[<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-4">OverrideBuiltins</a></code>] extended attribute.</p>
<li data-md="">
<p>Any other interface must not <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-11">inherit</a> from it.</p>
</ul>
<p>If [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-9">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-10">PrimaryGlobal</a></code>] is specified on
a <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-9">partial interface</a> definition, then that partial interface definition must
be the part of the interface definition that defines
the <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-5">named property getter</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-11">Global</a></code>] and [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-12">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-51">extended attribute</a> must not
be used on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-63">interface</a> that can have more
than one object implementing it in the same ECMAScript global environment.</p>
<p class="note" role="note">Note: This is because the <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-4">named properties object</a>,
which exposes the named properties, is in the prototype chain, and it would not make
sense for more than one object’s named properties to be exposed on an object that
all of those objects inherit from.</p>
<p>If an interface is declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-13">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-14">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-52">extended attribute</a>, then
there must not be more than one <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-15">interface member</a> across
the interface and its <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-15">consequential interfaces</a> with the same <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-51">identifier</a>.
There also must not be more than
one <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-2">stringifier</a>,
more than one <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-4">serializer</a>,
or more than one <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-8">iterable declaration</a>, <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-6">maplike declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-6">setlike declaration</a> across those interfaces.</p>
<p class="note" role="note">Note: This is because all of the members of the interface and its consequential
interfaces get flattened down on to the object that implements the interface.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-15">Global</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-16">PrimaryGlobal</a></code>] extended attributes
can also be used to give a name to one or more global interfaces,
which can then be referenced by the [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-21">Exposed</a></code>]
extended attribute.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-17">Global</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-18">PrimaryGlobal</a></code>]
extended attributes must either <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-4">take no arguments</a> or <a data-link-type="dfn" href="#dfn-xattr-identifier-list" id="ref-for-dfn-xattr-identifier-list-2">take an identifier list</a>.</p>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-19">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-20">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-53">extended attribute</a> is declared with an identifier list argument, then those identifiers are the interface’s <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-global-name">global names</dfn>; otherwise, the interface has
a single global name, which is the interface’s identifier.</p>
<p class="note" role="note">Note: The identifier argument list exists so that more than one global interface can
be addressed with a single name in an [<code class="idl"><a data-link-type="idl" href="#Exposed" id="ref-for-Exposed-22">Exposed</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-54">extended attribute</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-21">Global</a></code>] and
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-22">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-55">extended attributes</a> must not be declared on the same
interface. The [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-23">PrimaryGlobal</a></code>]
extended attribute must be declared on
at most one interface. The interface [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-24">PrimaryGlobal</a></code>]
is declared on, if any, is known as the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-primary-global-interface">primary global interface</dfn>.</p>
<p>See <a href="#named-properties-object">§3.6.4 Named properties object</a>, <a href="#getownproperty">§3.8.3 Platform object [[GetOwnProperty]] method</a> and <a href="#defineownproperty">§3.8.7 Platform object [[DefineOwnProperty]] method</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-25">Global</a></code>] and [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-26">PrimaryGlobal</a></code>]
entails for named properties,
and <a href="#es-constants">§3.6.5 Constants</a>, <a href="#es-attributes">§3.6.6 Attributes</a> and <a href="#es-operations">§3.6.7 Operations</a> for the requirements relating to the location of properties
corresponding to <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-16">interface members</a>.</p>
<div class="example" id="example-2b45d97a">
<a class="self-link" href="#example-2b45d97a"></a>
<p>The [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-27">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-56">extended attribute</a> is intended
to be used by the <code class="idl"><a data-link-type="idl" href="https://html.spec.whatwg.org/multipage/browsers.html#window">Window</a></code> interface.
([<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-28">Global</a></code>] is intended to be used by worker global interfaces.)
The <code class="idl">Window</code> interface exposes frames as properties on the <code class="idl">Window</code> object. Since the <code class="idl">Window</code> object also serves as the
ECMAScript global object, variable declarations or assignments to the named properties
will result in them being replaced by the new value. Variable declarations for
attributes will not create a property that replaces the existing one.</p>
<pre class="highlight">[<span class="nv">PrimaryGlobal</span>]
<span class="kt">interface</span> <span class="nv">Window</span> {
<span class="kt">getter</span> <span class="kt">any</span> (<span class="kt">DOMString</span> <span class="nv">name</span>);
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
// ...
};
</pre>
<p>The following HTML document illustrates how the named properties on the <code class="idl">Window</code> object can be shadowed, and how
the property for an attribute will not be replaced when declaring
a variable of the same name:</p>
<pre class="highlight"><span class="cp"><!DOCTYPE html></span>
<span class="p"><</span><span class="nt">title</span><span class="p">></span>Variable declarations and assignments on Window<span class="p"><</span><span class="p">/</span><span class="nt">title</span><span class="p">></span>
<span class="p"><</span><span class="nt">iframe</span> <span class="na">name</span><span class="o">=</span><span class="s">abc</span><span class="p">></span><span class="p"><</span><span class="p">/</span><span class="nt">iframe</span><span class="p">></span>
<span class="c"><!--</span><span class="c"> Shadowing named properties </span><span class="c">--></span>
<span class="p"><</span><span class="nt">script</span><span class="p">></span>
window<span class="p">.</span>abc<span class="p">;</span> <span class="c1">// Evaluates to the iframe’s Window object.
</span> abc <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="c1">// Shadows the named property.
</span> window<span class="p">.</span>abc<span class="p">;</span> <span class="c1">// Evaluates to 1.
</span><span class="p"><</span><span class="p">/</span><span class="nt">script</span><span class="p">></span>
<span class="c"><!--</span><span class="c"> Preserving properties for IDL attributes </span><span class="c">--></span>
<span class="p"><</span><span class="nt">script</span><span class="p">></span>
Window<span class="p">.</span>prototype<span class="p">.</span>def <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="c1">// Places a property on the prototype.
</span> window<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"length"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to true.
</span> length<span class="p">;</span> <span class="c1">// Evaluates to 1.
</span> def<span class="p">;</span> <span class="c1">// Evaluates to 2.
</span><span class="p"><</span><span class="p">/</span><span class="nt">script</span><span class="p">></span>
<span class="p"><</span><span class="nt">script</span><span class="p">></span>
<span class="kd">var</span> length<span class="p">;</span> <span class="c1">// Variable declaration leaves existing property.
</span> length<span class="p">;</span> <span class="c1">// Evaluates to 1.
</span> <span class="kd">var</span> def<span class="p">;</span> <span class="c1">// Variable declaration creates shadowing property.
</span> def<span class="p">;</span> <span class="c1">// Evaluates to undefined.
</span><span class="p"><</span><span class="p">/</span><span class="nt">script</span><span class="p">></span>
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.6" data-lt="LegacyArrayClass" id="LegacyArrayClass"><span class="secno">3.3.6. </span><span class="content">[LegacyArrayClass]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-3">LegacyArrayClass</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-57">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-64">interface</a> that is not defined to <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-12">inherit</a> from another, it indicates that the internal [[Prototype]]
property of its <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-5">interface prototype object</a> will be the <emu-val>Array</emu-val> prototype object rather than
the <emu-val>Object</emu-val> prototype object. This allows <emu-val>Array</emu-val> methods to be used more easily
with objects implementing the interface.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-4">LegacyArrayClass</a></code>] extended attribute
must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-5">take no arguments</a>.
It must not be used on an interface that
has any <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-14">inherited interfaces</a>.</p>
<p class="note" role="note">Note: Interfaces using [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-5">LegacyArrayClass</a></code>] will
need to define a “length” <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-46">attribute</a> of type <code class="idl"><a data-link-type="idl" href="#idl-unsigned-long" id="ref-for-idl-unsigned-long-16">unsigned long</a></code> that exposes the length
of the array-like object, in order for the inherited <emu-val>Array</emu-val> methods to operate correctly. Such interfaces would typically also <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-7">support indexed properties</a>,
which would provide access to the array elements.</p>
<p>See <a href="#interface-prototype-object">§3.6.3 Interface prototype object</a> for the
specific requirements that the use of [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-6">LegacyArrayClass</a></code>]
entails.</p>
<div class="example" id="example-2664cf61">
<a class="self-link" href="#example-2664cf61"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-36">IDL fragment</a> defines two <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-65">interfaces</a> that use [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-7">LegacyArrayClass</a></code>].</p>
<pre class="highlight">[<span class="nv">LegacyArrayClass</span>]
<span class="kt">interface</span> <span class="nv">ItemList</span> {
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">length</span>;
<span class="kt">getter</span> <span class="kt">object</span> <span class="nv">getItem</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>);
<span class="kt">setter</span> <span class="kt">object</span> <span class="nv">setItem</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>, <span class="kt">object</span> <span class="nv">item</span>);
};
[<span class="nv">LegacyArrayClass</span>]
<span class="kt">interface</span> <span class="nv">ImmutableItemList</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">length</span>;
<span class="kt">getter</span> <span class="kt">object</span> <span class="nv">getItem</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">index</span>);
};
</pre>
<p>In an ECMAScript implementation of the above two interfaces,
with appropriate definitions for getItem, setItem and removeItem, <emu-val>Array</emu-val> methods to inspect and
modify the array-like object can be used.</p>
<pre class="highlight"><span class="kd">var</span> list <span class="o">=</span> getItemList<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of ItemList.
</span>
list<span class="p">.</span>concat<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Clone the ItemList into an Array.
</span>list<span class="p">.</span>pop<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Remove an item from the ItemList.
</span>list<span class="p">.</span>unshift<span class="p">(</span><span class="p">{</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Insert an item at index 0.
</span></pre>
<p><code class="idl">ImmutableItemList</code> has a read only
length <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-47">attribute</a> and no indexed property <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-3">setter</a>. The
mutating <emu-val>Array</emu-val> methods will generally not
succeed on objects implementing <code class="idl">ImmutableItemList</code>.
The exact behavior depends on the definition of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-array-prototype-object">Array methods</a> themselves.</p>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.7" data-lt="LegacyUnenumerableNamedProperties" id="LegacyUnenumerableNamedProperties"><span class="secno">3.3.7. </span><span class="content">[LegacyUnenumerableNamedProperties]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-1">LegacyUnenumerableNamedProperties</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-58">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-66">interface</a> that <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-2">supports named properties</a>,
it indicates that all the interface’s named properties are unenumerable.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-2">LegacyUnenumerableNamedProperties</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-6">take no arguments</a> and must not appear on an interface
that does not define a <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-6">named property getter</a>.</p>
<p>If the [<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-3">LegacyUnenumerableNamedProperties</a></code>]
extended attribute is specified on an interface, then it applies to all its derived interfaces and
must not be specified on any of them.</p>
<p>See <a href="#property-enumeration">§3.8.10 Property enumeration</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-4">LegacyUnenumerableNamedProperties</a></code>]
entails.</p>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.8" data-lt="LenientSetter" id="LenientSetter"><span class="secno">3.3.8. </span><span class="content">[LenientSetter]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-2">LenientSetter</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-59">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-6">read only</a> <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-5">regular attribute</a>,
it indicates that a no-op setter will be generated for the attribute’s
accessor property. This results in erroneous assignments to the property
in strict mode to be ignored rather than causing an exception to be thrown.</p>
<div class="advisement">
<p>Specifications should not use [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-3">LenientSetter</a></code>]
unless required for compatibility reasons. Pages have been observed
where authors have attempted to polyfill an IDL attribute by assigning
to the property, but have accidentally done so even if the property
exists. In strict mode, this would cause an exception to be thrown,
potentially breaking page. Without [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-4">LenientSetter</a></code>],
this could prevent a browser from shipping the feature.</p>
<p>Specification authors who
wish to use this feature are strongly advised to discuss this on the <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a> mailing list before proceeding.</p>
</div>
<p>The [<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-2">LenientThis</a></code>] extended attribute
must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-7">take no arguments</a>.
It must not be used on anything other than
a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-7">read only</a> <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-6">regular attribute</a>.</p>
<p>An attribute with the [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-5">LenientSetter</a></code>]
extended attribute must not also be declared
with the [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-2">PutForwards</a></code>]
or [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-2">Replaceable</a></code>] extended attributes.</p>
<p>See the <a href="#es-attributes">Attributes</a> section for how
[<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-6">LenientSetter</a></code>]
is to be implemented.</p>
<div class="example" id="example-c0b45430">
<a class="self-link" href="#example-c0b45430"></a>
<p>The following IDL fragment defines an interface that uses the
[<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-7">LenientSetter</a></code>] extended
attribute.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Example</span> {
[<span class="nv">LenientSetter</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">x</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">y</span>;
};
</pre>
<p>An ECMAScript implementation that supports this interface will
have a setter on the accessor property that correspond to x,
which allows any assignment to be ignored in strict mode.</p>
<pre class="highlight"><span class="s2">"use strict"</span><span class="p">;</span>
<span class="kd">var</span> example <span class="o">=</span> getExample<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of Example.
</span>
<span class="c1">// Fine; while we are in strict mode, there is a setter that is a no-op.
</span>example<span class="p">.</span>x <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="c1">// Throws a TypeError, since we are in strict mode and there is no setter.
</span>example<span class="p">.</span>y <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.9" data-lt="LenientThis" id="LenientThis"><span class="secno">3.3.9. </span><span class="content">[LenientThis]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-3">LenientThis</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-60">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-7">regular attribute</a>,
it indicates that invocations of the attribute’s getter or setter
with a <emu-val>this</emu-val> value that is not an
object that implements the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-67">interface</a> on which the attribute appears will be ignored.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-4">LenientThis</a></code>] extended attribute
must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-8">take no arguments</a>.
It must not be used on a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-7">static attribute</a>.</p>
<p class="advisement"> Specifications should not use [<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-5">LenientThis</a></code>]
unless required for compatibility reasons. Specification authors who
wish to use this feature are strongly advised to discuss this on the <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a> mailing list before proceeding. </p>
<p>See the <a href="#es-attributes">Attributes</a> section for how
[<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-6">LenientThis</a></code>]
is to be implemented.</p>
<div class="example" id="example-9e113db6">
<a class="self-link" href="#example-9e113db6"></a>
<p>The following IDL fragment defines an interface that uses the
[<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-7">LenientThis</a></code>] extended
attribute.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Example</span> {
[<span class="nv">LenientThis</span>] <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">x</span>;
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">y</span>;
};
</pre>
<p>An ECMAScript implementation that supports this interface will
allow the getter and setter of the accessor property that corresponds
to x to be invoked with something other than an <code class="idl">Example</code> object.</p>
<pre class="highlight"><span class="kd">var</span> example <span class="o">=</span> getExample<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of Example.
</span><span class="kd">var</span> obj <span class="o">=</span> <span class="p">{</span> <span class="p">}</span><span class="p">;</span>
<span class="c1">// Fine.
</span>example<span class="p">.</span>x<span class="p">;</span>
<span class="c1">// Ignored, since the this value is not an Example object and [LenientThis] is used.
</span>Object<span class="p">.</span>getOwnPropertyDescriptor<span class="p">(</span>Example<span class="p">.</span>prototype<span class="p">,</span> <span class="s2">"x"</span><span class="p">)</span><span class="p">.</span>get<span class="p">.</span>call<span class="p">(</span>obj<span class="p">)</span><span class="p">;</span>
<span class="c1">// Also ignored, since Example.prototype is not an Example object and [LenientThis] is used.
</span>Example<span class="p">.</span>prototype<span class="p">.</span>x<span class="p">;</span>
<span class="c1">// Throws a TypeError, since Example.prototype is not an Example object.
</span>Example<span class="p">.</span>prototype<span class="p">.</span>y<span class="p">;</span>
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.10" data-lt="NamedConstructor" id="NamedConstructor"><span class="secno">3.3.10. </span><span class="content">[NamedConstructor]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-8">NamedConstructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-61">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-68">interface</a>,
it indicates that the ECMAScript global object will have a property with the
specified name whose value is a constructor function that can
create objects that implement the interface.
Multiple [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-9">NamedConstructor</a></code>] extended
attributes may appear on a given interface.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-10">NamedConstructor</a></code>]
extended attribute must either <a data-link-type="dfn" href="#dfn-xattr-identifier" id="ref-for-dfn-xattr-identifier-2">take an identifier</a> or <a data-link-type="dfn" href="#dfn-xattr-named-argument-list" id="ref-for-dfn-xattr-named-argument-list-3">take a named argument list</a>.
The first form, <code>[NamedConstructor=<emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t>]</code>, has the same meaning as
using an empty argument list, <code>[NamedConstructor=<emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t>()]</code>. For each
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-11">NamedConstructor</a></code>] extended attribute
on the interface, there will be a way to construct an object that implements
the interface by passing the specified arguments to the constructor function
that is the value of the aforementioned property.</p>
<p>The identifier used for the named constructor must not
be the same as that used by an [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-12">NamedConstructor</a></code>]
extended attribute on another interface, must not
be the same as an identifier of an interface
that has an <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-4">interface object</a>,
and must not be one of the <a data-link-type="dfn" href="#dfn-reserved-identifier" id="ref-for-dfn-reserved-identifier-1">reserved identifiers</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-13">NamedConstructor</a></code>] extended attribute
must not be used on a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-19">callback interface</a>.</p>
<p>See <a href="#named-constructors">§3.6.2 Named constructors</a> for details on how named constructors
are to be implemented.</p>
<div class="example" id="example-01cfa49c">
<a class="self-link" href="#example-01cfa49c"></a>
<p>The following IDL defines an interface that uses the
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-14">NamedConstructor</a></code>] extended
attribute.</p>
<pre class="highlight">[<span class="nv">NamedConstructor</span>=<span class="n">Audio</span>,
<span class="nv">NamedConstructor</span>=<span class="n">Audio</span>(<span class="kt">DOMString</span> <span class="nv">src</span>)]
<span class="kt">interface</span> <span class="nv">HTMLAudioElement</span> : <span class="n">HTMLMediaElement</span> {
// ...
};
</pre>
<p>An ECMAScript implementation that supports this interface will
allow the construction of <code class="idl">HTMLAudioElement</code> objects using the <code class="idl">Audio</code> constructor.</p>
<pre class="highlight"><span class="k">typeof</span> Audio<span class="p">;</span> <span class="c1">// Evaluates to 'function'.
</span>
<span class="kd">var</span> a1 <span class="o">=</span> <span class="k">new</span> Audio<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Creates a new object that implements
</span> <span class="c1">// HTMLAudioElement, using the zero-argument
</span> <span class="c1">// constructor.
</span>
<span class="kd">var</span> a2 <span class="o">=</span> <span class="k">new</span> Audio<span class="p">(</span><span class="s1">'a.flac'</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Creates an HTMLAudioElement using the
</span> <span class="c1">// one-argument constructor.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.11" data-lt="NewObject" id="NewObject"><span class="secno">3.3.11. </span><span class="content">[NewObject]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#NewObject" id="ref-for-NewObject-2">NewObject</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-62">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-9">regular</a> or <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-7">static</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-54">operation</a>,
then it indicates that when calling the operation,
a reference to a newly created object
must always be returned.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NewObject" id="ref-for-NewObject-3">NewObject</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-9">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NewObject" id="ref-for-NewObject-4">NewObject</a></code>]
extended attribute must not
be used on anything other than a <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-10">regular</a> or <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-8">static</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-55">operation</a> whose <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-4">return type</a> is an <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-11">interface type</a> or
a <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-7">promise type</a>.</p>
<div class="example" id="example-245e5507">
<a class="self-link" href="#example-245e5507"></a>
<p>As an example, this extended attribute is suitable for use on
the <a href="http://dom.spec.whatwg.org/#dom-document-createelement">createElement</a> operation on the <a href="http://dom.spec.whatwg.org/#document"><code class="idl">Document</code></a> interface (<a data-link-type="biblio" href="#biblio-dom">[DOM]</a>, section 6.5),
since a new object should always be returned when
it is called.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Document</span> : <span class="n">Node</span> {
[<span class="nv">NewObject</span>] <span class="n">Element</span> <span class="nv">createElement</span>(<span class="kt">DOMString</span> <span class="nv">localName</span>);
// ...
};
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.12" data-lt="NoInterfaceObject" id="NoInterfaceObject"><span class="secno">3.3.12. </span><span class="content">[NoInterfaceObject]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-4">NoInterfaceObject</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-63">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-69">interface</a>,
it indicates that an <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-5">interface object</a> will not exist for the interface in the ECMAScript binding.</p>
<p class="advisement"> The [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-5">NoInterfaceObject</a></code>] extended attribute
should not be used on interfaces that are not
solely used as <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-4">supplemental</a> interfaces,
unless there are clear Web compatibility reasons for doing so. Specification authors who
wish to use this feature are strongly advised to discuss this on the <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a> mailing list before proceeding. </p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-6">NoInterfaceObject</a></code>] extended attribute
must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-10">take no arguments</a>.</p>
<p>If the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-7">NoInterfaceObject</a></code>] extended attribute
is specified on an interface, then the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-19">Constructor</a></code>]
extended attribute must not also be specified on that interface.
A [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-15">NamedConstructor</a></code>] extended attribute is fine,
however.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-8">NoInterfaceObject</a></code>] extended attribute
must not be specified on an interface that has any <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-9">static operations</a> defined on it.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-9">NoInterfaceObject</a></code>] extended attribute
must not be specified on a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-20">callback interface</a> unless it has a <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-20">constant</a> declared on it.
This is because callback interfaces without constants never have <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-6">interface objects</a>.</p>
<p>An interface that does not have the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-10">NoInterfaceObject</a></code>] extended
attribute specified must not inherit
from an interface that has the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-11">NoInterfaceObject</a></code>] extended
attribute specified.</p>
<p>See <a href="#es-interfaces">§3.6 Interfaces</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-12">NoInterfaceObject</a></code>] entails.</p>
<div class="example" id="example-1d2cfd36">
<a class="self-link" href="#example-1d2cfd36"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-37">IDL fragment</a> defines two interfaces, one whose interface object
is exposed on the ECMAScript global object, and one whose isn’t:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Storage</span> {
<span class="kt">void</span> <span class="nv">addEntry</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">key</span>, <span class="kt">any</span> <span class="nv">value</span>);
};
[<span class="nv">NoInterfaceObject</span>]
<span class="kt">interface</span> <span class="nv">Query</span> {
<span class="kt">any</span> <span class="nv">lookupEntry</span>(<span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">key</span>);
};
</pre>
<p>An ECMAScript implementation of the above IDL would allow
manipulation of <code class="idl">Storage</code>’s
prototype, but not <code class="idl">Query</code>’s.</p>
<pre class="highlight"><span class="k">typeof</span> Storage<span class="p">;</span> <span class="c1">// evaluates to "object"
</span>
<span class="c1">// Add some tracing alert() call to Storage.addEntry.
</span><span class="kd">var</span> fn <span class="o">=</span> Storage<span class="p">.</span>prototype<span class="p">.</span>addEntry<span class="p">;</span>
Storage<span class="p">.</span>prototype<span class="p">.</span>addEntry <span class="o">=</span> <span class="kd">function</span><span class="p">(</span>key<span class="p">,</span> value<span class="p">)</span> <span class="p">{</span>
alert<span class="p">(</span><span class="s1">'Calling addEntry()'</span><span class="p">)</span><span class="p">;</span>
<span class="k">return</span> fn<span class="p">.</span>call<span class="p">(</span><span class="k">this</span><span class="p">,</span> key<span class="p">,</span> value<span class="p">)</span><span class="p">;</span>
<span class="p">}</span><span class="p">;</span>
<span class="k">typeof</span> Query<span class="p">;</span> <span class="c1">// evaluates to "undefined"
</span><span class="kd">var</span> fn <span class="o">=</span> Query<span class="p">.</span>prototype<span class="p">.</span>lookupEntry<span class="p">;</span> <span class="c1">// exception, Query isn’t defined
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.13" data-lt="OverrideBuiltins" id="OverrideBuiltins"><span class="secno">3.3.13. </span><span class="content">[OverrideBuiltins]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-5">OverrideBuiltins</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-64">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-70">interface</a>,
it indicates that for a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-15">platform object</a> implementing the interface,
properties corresponding to all of
the object’s <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-3">supported property names</a> will appear to be on the object,
regardless of what other properties exist on the object or its
prototype chain. This means that named properties will always shadow
any properties that would otherwise appear on the object.
This is in contrast to the usual behavior, which is for named properties
to be exposed only if there is no property with the
same name on the object itself or somewhere on its prototype chain.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-6">OverrideBuiltins</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-11">take no arguments</a> and must not appear on an interface
that does not define a <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-7">named property getter</a> or that also is declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-29">Global</a></code>]
or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-30">PrimaryGlobal</a></code>]
extended attribute. If the extended attribute is specified on
a <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-10">partial interface</a> definition, then that partial interface definition must
be the part of the interface definition that defines
the <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-8">named property getter</a>.</p>
<p>See <a href="#indexed-and-named-properties">§3.8.1 Indexed and named properties</a> and <a href="#defineownproperty">§3.8.7 Platform object [[DefineOwnProperty]] method</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-7">OverrideBuiltins</a></code>] entails.</p>
<div class="example" id="example-1f93745b">
<a class="self-link" href="#example-1f93745b"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-38">IDL fragment</a> defines two <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-71">interfaces</a>,
one that has a <a data-link-type="dfn" href="#dfn-named-property-getter" id="ref-for-dfn-named-property-getter-9">named property getter</a> and one that does not.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">StringMap</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">length</span>;
<span class="kt">getter</span> <span class="kt">DOMString</span> <span class="nv">lookup</span>(<span class="kt">DOMString</span> <span class="nv">key</span>);
};
[<span class="nv">OverrideBuiltins</span>]
<span class="kt">interface</span> <span class="nv">StringMap2</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">length</span>;
<span class="kt">getter</span> <span class="kt">DOMString</span> <span class="nv">lookup</span>(<span class="kt">DOMString</span> <span class="nv">key</span>);
};
</pre>
<p>In an ECMAScript implementation of these two interfaces,
getting certain properties on objects implementing
the interfaces will result in different values:</p>
<pre class="highlight"><span class="c1">// Obtain an instance of StringMap. Assume that it has "abc", "length" and
</span><span class="c1">// "toString" as supported property names.
</span><span class="kd">var</span> map1 <span class="o">=</span> getStringMap<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// This invokes the named property getter.
</span>map1<span class="p">.</span>abc<span class="p">;</span>
<span class="c1">// This fetches the "length" property on the object that corresponds to the
</span><span class="c1">// length attribute.
</span>map1<span class="p">.</span>length<span class="p">;</span>
<span class="c1">// This fetches the "toString" property from the object’s prototype chain.
</span>map1<span class="p">.</span>toString<span class="p">;</span>
<span class="c1">// Obtain an instance of StringMap2. Assume that it also has "abc", "length"
</span><span class="c1">// and "toString" as supported property names.
</span><span class="kd">var</span> map2 <span class="o">=</span> getStringMap2<span class="p">(</span><span class="p">)</span><span class="p">;</span>
<span class="c1">// This invokes the named property getter.
</span>map2<span class="p">.</span>abc<span class="p">;</span>
<span class="c1">// This also invokes the named property getter, despite the fact that the "length"
</span><span class="c1">// property on the object corresponds to the length attribute.
</span>map2<span class="p">.</span>length<span class="p">;</span>
<span class="c1">// This too invokes the named property getter, despite the fact that "toString" is
</span><span class="c1">// a property in map2’s prototype chain.
</span>map2<span class="p">.</span>toString<span class="p">;</span>
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.14" data-lt="PutForwards" id="PutForwards"><span class="secno">3.3.14. </span><span class="content">[PutForwards]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-3">PutForwards</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-65">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-8">read only</a> <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-8">regular attribute</a> declaration whose type is
an <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-12">interface type</a>,
it indicates that assigning to the attribute will have specific behavior.
Namely, the assignment is “forwarded” to the attribute (specified by
the extended attribute argument) on the object that is currently
referenced by the attribute being assigned to.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-4">PutForwards</a></code>] extended
attribute must <a data-link-type="dfn" href="#dfn-xattr-identifier" id="ref-for-dfn-xattr-identifier-3">take an identifier</a>.
Assuming that:</p>
<ul>
<li data-md="">
<p><var>A</var> is the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-48">attribute</a> on which the [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-5">PutForwards</a></code>]
extended attribute appears,</p>
<li data-md="">
<p><var>I</var> is the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-72">interface</a> on which <var>A</var> is declared,</p>
<li data-md="">
<p><var>J</var> is the <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-13">interface type</a> that <var>A</var> is declared to be of, and</p>
<li data-md="">
<p><var>N</var> is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-52">identifier</a> argument of the extended attribute,</p>
</ul>
<p>then there must be another <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-49">attribute</a> <var>B</var> declared on <var>J</var> whose <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-53">identifier</a> is <var>N</var>. Assignment of a value to the attribute <var>A</var> on an object implementing <var>I</var> will result in that value
being assigned to attribute <var>B</var> of the object that <var>A</var> references, instead.</p>
<p>Note that [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-6">PutForwards</a></code>]-annotated <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-50">attributes</a> can be
chained. That is, an attribute with the [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-7">PutForwards</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-66">extended attribute</a> can refer to an attribute that itself has that extended attribute.
There must not exist a cycle in a
chain of forwarded assignments. A cycle exists if, when following
the chain of forwarded assignments, a particular attribute on
an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-73">interface</a> is
encountered more than once.</p>
<p>An attribute with the [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-8">PutForwards</a></code>]
extended attribute must not also be declared
with the [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-8">LenientSetter</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-3">Replaceable</a></code>] extended attributes.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-9">PutForwards</a></code>]
extended attribute must not be used
on an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-51">attribute</a> that
is not <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-9">read only</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-10">PutForwards</a></code>] extended attribute
must not be used on a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-8">static attribute</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-11">PutForwards</a></code>] extended attribute
must not be used on an attribute declared on
a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-21">callback interface</a>.</p>
<p>See the <a href="#es-attributes">Attributes</a> section for how
[<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-12">PutForwards</a></code>]
is to be implemented.</p>
<div class="example" id="example-dda2a869">
<a class="self-link" href="#example-dda2a869"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-39">IDL fragment</a> defines interfaces for names and people.
The [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-13">PutForwards</a></code>] extended
attribute is used on the <code class="idl">name</code> attribute
of the <code class="idl">Person</code> interface to indicate
that assignments to that attribute result in assignments to the <code class="idl">full</code> attribute of the <code class="idl">Person</code> object:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Name</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">full</span>;
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">family</span>;
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">given</span>;
};
<span class="kt">interface</span> <span class="nv">Person</span> {
[<span class="nv">PutForwards</span>=<span class="n">full</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">Name</span> <span class="nv">name</span>;
<span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">short</span> <span class="nv">age</span>;
};
</pre>
<p>In the ECMAScript binding, this would allow assignments to the
“name” property:</p>
<pre class="highlight"><span class="kd">var</span> p <span class="o">=</span> getPerson<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of Person.
</span>
p<span class="p">.</span>name <span class="o">=</span> <span class="s1">'John Citizen'</span><span class="p">;</span> <span class="c1">// This statement...
</span>p<span class="p">.</span>name<span class="p">.</span>full <span class="o">=</span> <span class="s1">'John Citizen'</span><span class="p">;</span> <span class="c1">// ...has the same behavior as this one.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.15" data-lt="Replaceable" id="Replaceable"><span class="secno">3.3.15. </span><span class="content">[Replaceable]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-4">Replaceable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-67">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-10">read only</a> <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-9">regular attribute</a>,
it indicates that setting the corresponding property on the <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-16">platform object</a> will result in
an own property with the same name being created on the object
which has the value being assigned. This property will shadow
the accessor property corresponding to the attribute, which
exists on the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-6">interface prototype object</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-5">Replaceable</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-12">take no arguments</a>.</p>
<p>An attribute with the [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-6">Replaceable</a></code>]
extended attribute must not also be declared
with the [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-9">LenientSetter</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-14">PutForwards</a></code>] extended attributes.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-7">Replaceable</a></code>]
extended attribute must not be used
on an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-52">attribute</a> that
is not <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-11">read only</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-8">Replaceable</a></code>] extended attribute
must not be used on a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-9">static attribute</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-9">Replaceable</a></code>] extended attribute
must not be used on an attribute declared on
a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-22">callback interface</a>.</p>
<p>See <a href="#es-attributes">§3.6.6 Attributes</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-10">Replaceable</a></code>] entails.</p>
<div class="example" id="example-8ded6a51">
<a class="self-link" href="#example-8ded6a51"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-40">IDL fragment</a> defines an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-74">interface</a> with an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-56">operation</a> that increments a counter, and an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-53">attribute</a> that exposes the counter’s value, which is initially 0:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Counter</span> {
[<span class="nv">Replaceable</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="nv">value</span>;
<span class="kt">void</span> <span class="nv">increment</span>();
};
</pre>
<p>Assigning to the “value” property
on a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-17">platform object</a> implementing <code class="idl">Counter</code> will shadow the property that corresponds to the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-54">attribute</a>:</p>
<pre class="highlight"><span class="kd">var</span> counter <span class="o">=</span> getCounter<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of Counter.
</span>counter<span class="p">.</span>value<span class="p">;</span> <span class="c1">// Evaluates to 0.
</span>
counter<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"value"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to false.
</span>Object<span class="p">.</span>getPrototypeOf<span class="p">(</span>counter<span class="p">)</span><span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"value"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to true.
</span>
counter<span class="p">.</span>increment<span class="p">(</span><span class="p">)</span><span class="p">;</span>
counter<span class="p">.</span>increment<span class="p">(</span><span class="p">)</span><span class="p">;</span>
counter<span class="p">.</span>value<span class="p">;</span> <span class="c1">// Evaluates to 2.
</span>
counter<span class="p">.</span>value <span class="o">=</span> <span class="s1">'a'</span><span class="p">;</span> <span class="c1">// Shadows the property with one that is unrelated
</span> <span class="c1">// to Counter::value.
</span>
counter<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"value"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to true.
</span>
counter<span class="p">.</span>increment<span class="p">(</span><span class="p">)</span><span class="p">;</span>
counter<span class="p">.</span>value<span class="p">;</span> <span class="c1">// Evaluates to 'a'.
</span>
<span class="k">delete</span> counter<span class="p">.</span>value<span class="p">;</span> <span class="c1">// Reveals the original property.
</span>counter<span class="p">.</span>value<span class="p">;</span> <span class="c1">// Evaluates to 3.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.16" data-lt="SameObject" id="SameObject"><span class="secno">3.3.16. </span><span class="content">[SameObject]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#SameObject" id="ref-for-SameObject-2">SameObject</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-68">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-12">read only</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-55">attribute</a>, then it
indicates that when getting the value of the attribute on a given
object, the same value must always
be returned.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#SameObject" id="ref-for-SameObject-3">SameObject</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-13">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#SameObject" id="ref-for-SameObject-4">SameObject</a></code>]
extended attribute must not
be used on anything other than a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-13">read only</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-56">attribute</a> whose type is an <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-14">interface type</a> or <code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-25">object</a></code>.</p>
<div class="example" id="example-87c35b5d">
<a class="self-link" href="#example-87c35b5d"></a>
<p>As an example, this extended attribute is suitable for use on
the <a href="http://dom.spec.whatwg.org/#dom-document-implementation">implementation</a> attribute on the <a href="http://dom.spec.whatwg.org/#document"><code class="idl">Document</code></a> interface (<a data-link-type="biblio" href="#biblio-dom">[DOM]</a>, section 6.5),
since the same object is always returned for a given <code class="idl">Document</code> object.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Document</span> : <span class="n">Node</span> {
[<span class="nv">SameObject</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="n">DOMImplementation</span> <span class="nv">implementation</span>;
// ...
};
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.17" data-lt="SecureContext" id="SecureContext"><span class="secno">3.3.17. </span><span class="content">[SecureContext]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-9">SecureContext</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-69">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-75">interface</a>, <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-11">partial interface</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-8">namespace</a>, <a data-link-type="dfn" href="#dfn-partial-namespace" id="ref-for-dfn-partial-namespace-4">partial namespace</a>, <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-17">interface member</a>, or <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-5">namespace member</a>,
it indicates that the construct is exposed
only within a <a data-link-type="dfn" href="https://w3c.github.io/webappsec-secure-contexts/#secure-context">secure context</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-10">SecureContext</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-14">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-11">SecureContext</a></code>]
extended attribute must not
be used on anything other than an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-76">interface</a>, <a data-link-type="dfn" href="#dfn-partial-interface" id="ref-for-dfn-partial-interface-12">partial interface</a>, <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-9">namespace</a>, <a data-link-type="dfn" href="#dfn-partial-namespace" id="ref-for-dfn-partial-namespace-5">partial namespace</a>, <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-18">interface member</a>, or <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-6">namespace member</a>.</p>
<p>Whether a construct that the [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-12">SecureContext</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-70">extended attribute</a> can be specified on is <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-available-only-in-secure-contexts">available only in secure contexts</dfn> is defined as follows:</p>
<ul>
<li data-md="">
<p>If the [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-13">SecureContext</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-71">extended attribute</a> is specified on the construct, then it is <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-2">available only in secure contexts</a>.</p>
<li data-md="">
<p>Otherwise, if the [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-14">SecureContext</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-72">extended attribute</a> does not appear on a construct, then whether it is <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-3">available only in secure contexts</a> depends on the type of construct:</p>
<dl class="switch">
<dt data-md="">
<p>interface</p>
<dt data-md="">
<p>namespace</p>
<dd data-md="">
<p>The interface or namespace is not <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-4">available only in secure contexts</a>.</p>
<dt data-md="">
<p>partial interface</p>
<dt data-md="">
<p>partial namespace</p>
<dd data-md="">
<p>The partial interface or partial namespace is <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-5">available only in secure contexts</a> if and only if the original interface or namespace definition
is.</p>
<dt data-md="">
<p>interface member</p>
<dd data-md="">
<p>The interface member is <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-6">available only in secure contexts</a> if and only if the interface or partial interface the member is declared on is.</p>
<dt data-md="">
<p>namespace member</p>
<dd data-md="">
<p>The namespace member is <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-7">available only in secure contexts</a> if and only if the namspace or partial namespace the member is declared on is.</p>
</dl>
</ul>
<p class="note" role="note">Note: Whether a construct is <a data-link-type="dfn" href="#dfn-available-only-in-secure-contexts" id="ref-for-dfn-available-only-in-secure-contexts-8">available only in secure contexts</a> influences whether it is <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-1">exposed</a> in a given
ECMAScript global environment.</p>
<p>If [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-15">SecureContext</a></code>] appears on an <a data-link-type="dfn" href="#dfn-overloaded" id="ref-for-dfn-overloaded-3">overloaded</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-57">operation</a>,
then it must appear on all overloads.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-16">SecureContext</a></code>] extended attribute
must not be specified on both an interface member and the
interface or partial interface definition the interface member is declared on, or
on both a namespace member and the namespace or partial namespace definition the
namespace member is declared on.</p>
<p>An interface without the [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-17">SecureContext</a></code>] extended attribute
must not <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-13">inherit</a> from another interface
that does specify [<code class="idl"><a data-link-type="idl" href="#SecureContext" id="ref-for-SecureContext-18">SecureContext</a></code>].</p>
<div class="example" id="example-3be198d4">
<a class="self-link" href="#example-3be198d4"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-41">IDL fragment</a> defines an interface
with one <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-58">operation</a> that is executable from all
contexts, and two which are executable only from secure contexts.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">PowerfulFeature</span> {
// This call will succeed in all contexts.
<span class="kt">Promise</span> <<span class="n">Result</span>> <span class="nv">calculateNotSoSecretResult</span>();
// This operation will not be exposed to a non-secure context. In such a context,
// there will be no "calculateSecretResult" property on PowerfulFeature.prototype.
[<span class="nv">SecureContext</span>] <span class="kt">Promise</span><<span class="n">Result</span>> <span class="nv">calculateSecretResult</span>();
// The same applies here: the attribute will not be exposed to a non-secure context,
// and in a non-secure context there will be no "secretBoolean" property on
// PowerfulFeature.prototype.
[<span class="nv">SecureContext</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">boolean</span> <span class="nv">secretBoolean</span>;
};
</pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.18" data-lt="TreatNonObjectAsNull" id="TreatNonObjectAsNull"><span class="secno">3.3.18. </span><span class="content">[TreatNonObjectAsNull]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-5">TreatNonObjectAsNull</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-73">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-22">callback function</a>,
then it indicates that any value assigned to an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-57">attribute</a> whose type is a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-25">nullable</a> <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-23">callback function</a> that is not an object will be converted to
the <emu-val>null</emu-val> value.</p>
<p class="advisement"> Specifications should not use [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-6">TreatNonObjectAsNull</a></code>]
unless required to specify the behavior of legacy APIs or for consistency with these
APIs. Specification authors who
wish to use this feature are strongly advised to discuss this on the <a href="mailto:public-script-coord@w3.org">public-script-coord@w3.org</a> mailing list before proceeding. At the time of writing, the only known
valid use of [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-7">TreatNonObjectAsNull</a></code>]
is for the <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-24">callback functions</a> used as the type
of <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-attributes">event handler IDL attributes</a> such as <code>onclick</code> and <code>onerror</code>. </p>
<p>See <a href="#es-nullable-type">§3.2.24 Nullable types — T?</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-8">TreatNonObjectAsNull</a></code>] entails.</p>
<div class="example" id="example-28226fc6">
<a class="self-link" href="#example-28226fc6"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-42">IDL fragment</a> defines an interface that has one
attribute whose type is a [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-9">TreatNonObjectAsNull</a></code>]-annotated <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-25">callback function</a> and another whose type is a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-26">callback function</a> without the <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-74">extended attribute</a>:</p>
<pre class="highlight"><span class="kt">callback</span> <span class="nv">OccurrenceHandler</span> = <span class="kt">void</span> (<span class="kt">DOMString</span> <span class="nv">details</span>);
[<span class="nv">TreatNonObjectAsNull</span>]
<span class="kt">callback</span> <span class="nv">ErrorHandler</span> = <span class="kt">void</span> (<span class="kt">DOMString</span> <span class="nv">details</span>);
<span class="kt">interface</span> <span class="nv">Manager</span> {
<span class="kt">attribute</span> <span class="n">OccurrenceHandler</span>? <span class="nv">handler1</span>;
<span class="kt">attribute</span> <span class="n">ErrorHandler</span>? <span class="nv">handler2</span>;
};
</pre>
<p>In an ECMAScript implementation, assigning a value that is not
an object (such as a <emu-val>Number</emu-val> value)
to handler1 will have different behavior from that when assigning
to handler2:</p>
<pre class="highlight"><span class="kd">var</span> manager <span class="o">=</span> getManager<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of Manager.
</span>
manager<span class="p">.</span>handler1 <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> <span class="p">}</span><span class="p">;</span>
manager<span class="p">.</span>handler1<span class="p">;</span> <span class="c1">// Evaluates to the function.
</span>
<span class="k">try</span> <span class="p">{</span>
manager<span class="p">.</span>handler1 <span class="o">=</span> <span class="mi">123</span><span class="p">;</span> <span class="c1">// Throws a TypeError.
</span><span class="p">}</span> <span class="k">catch</span> <span class="p">(</span>e<span class="p">)</span> <span class="p">{</span>
<span class="p">}</span>
manager<span class="p">.</span>handler2 <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> <span class="p">}</span><span class="p">;</span>
manager<span class="p">.</span>handler2<span class="p">;</span> <span class="c1">// Evaluates to the function.
</span>
manager<span class="p">.</span>handler2 <span class="o">=</span> <span class="mi">123</span><span class="p">;</span>
manager<span class="p">.</span>handler2<span class="p">;</span> <span class="c1">// Evaluates to null.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.19" data-lt="TreatNullAs" id="TreatNullAs"><span class="secno">3.3.19. </span><span class="content">[TreatNullAs]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-8">TreatNullAs</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-75">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-58">attribute</a> or <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-59">operation</a> argument whose type is <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-45">DOMString</a></code>,
it indicates that a <emu-val>null</emu-val> value
assigned to the attribute or passed as the operation argument will be
handled differently from its default handling. Instead of being stringified
to “null”, which is the default,
it will be converted to the empty string “”.</p>
<p>If [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-9">TreatNullAs</a></code>] is specified on
an operation itself, and that operation is on a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-23">callback interface</a>,
then it indicates that a <a href="#es-user-objects">user object implementing the interface</a> will have the return
value of the function that implements the operation handled in the same way as for operation arguments
and attributes, as above.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-10">TreatNullAs</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-identifier" id="ref-for-dfn-xattr-identifier-4">take the identifier</a> <code>EmptyString</code>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-11">TreatNullAs</a></code>] extended attribute
must not be specified on an operation argument,
attribute or operation return value whose type is not <code class="idl"><a data-link-type="idl" href="#idl-DOMString" id="ref-for-idl-DOMString-46">DOMString</a></code>.</p>
<p class="note" role="note">Note: This means that even an attribute of type <code class="idl">DOMString?</code> must not
use [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-12">TreatNullAs</a></code>], since <emu-val>null</emu-val> is a valid value of that type.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-13">TreatNullAs</a></code>] extended attribute
also must not be specified on an operation on
a non-callback interface.</p>
<p>See <a href="#es-DOMString">§3.2.16 DOMString</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-14">TreatNullAs</a></code>] entails.</p>
<div class="example" id="example-50724365">
<a class="self-link" href="#example-50724365"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-43">IDL fragment</a> defines an interface that has one
attribute with the [<code class="idl"><a data-link-type="idl" href="#TreatNullAs" id="ref-for-TreatNullAs-15">TreatNullAs</a></code>]
extended attribute, and one operation with an argument that has
the extended attribute:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Dog</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">name</span>;
[<span class="nv">TreatNullAs</span>=<span class="n">EmptyString</span>] <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">owner</span>;
<span class="kt">boolean</span> <span class="nv">isMemberOfBreed</span>([<span class="nv">TreatNullAs</span>=<span class="n">EmptyString</span>] <span class="kt">DOMString</span> <span class="nv">breedName</span>);
};
</pre>
<p>An ECMAScript implementation implementing the <code class="idl">Dog</code> interface would convert a <emu-val>null</emu-val> value
assigned to the “owner” property or passed as the
argument to the <code>isMemberOfBreed</code> function
to the empty string rather than <code>"null"</code>:</p>
<pre class="highlight"><span class="kd">var</span> d <span class="o">=</span> getDog<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Assume d is a platform object implementing the Dog
</span> <span class="c1">// interface.
</span>
d<span class="p">.</span>name <span class="o">=</span> <span class="kc">null</span><span class="p">;</span> <span class="c1">// This assigns the string "null" to the .name
</span> <span class="c1">// property.
</span>
d<span class="p">.</span>owner <span class="o">=</span> <span class="kc">null</span><span class="p">;</span> <span class="c1">// This assigns the string "" to the .owner property.
</span>
d<span class="p">.</span>isMemberOfBreed<span class="p">(</span><span class="kc">null</span><span class="p">)</span><span class="p">;</span> <span class="c1">// This passes the string "" to the isMemberOfBreed
</span> <span class="c1">// function.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.20" data-lt="Unforgeable" id="Unforgeable"><span class="secno">3.3.20. </span><span class="content">[Unforgeable]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-5">Unforgeable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-76">extended attribute</a> appears on a non-<a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-10">static</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-59">attribute</a> or non-<a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-10">static</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-60">operations</a>, it indicates
that the attribute or operation will be reflected as an ECMAScript property in
a way that means its behavior cannot be modified and that performing
a property lookup on the object will always result in the attribute’s
property value being returned. In particular, the property will be
non-configurable and will exist as an own property on the object
itself rather than on its prototype.</p>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-6">Unforgeable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-77">extended attribute</a> appears on an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-77">interface</a>,
it indicates that all of the non-<a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-11">static</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-60">attributes</a> and non-<a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-11">static</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-61">operations</a> declared on
that interface and its <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-16">consequential interfaces</a> will be similarly reflected as own ECMAScript properties on objects
that implement the interface, rather than on the prototype.</p>
<p>An attribute or operation is said to be <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-unforgeable-on-an-interface">unforgeable</dfn> on a given interface <var>A</var> if any of the following are true:</p>
<ul>
<li data-md="">
<p>The attribute or operation is declared on <var>A</var> or one
of <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-17">consequential interfaces</a>,
and is annotated with the [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-7">Unforgeable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-78">extended attribute</a>.</p>
<li data-md="">
<p>The attribute or operation is declared on <var>A</var> or one
of <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-18">consequential interfaces</a>,
and that interface is annotated with the [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-8">Unforgeable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-79">extended attribute</a>.</p>
<li data-md="">
<p>There exists an interface <var>B</var>, which is either <var>A</var> or one of <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-19">consequential interfaces</a>, <var>B</var> is annotated with the [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-9">Unforgeable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-80">extended attribute</a>,
and the attribute or operation is declared on one of <var>B</var>’s consequential interfaces.</p>
</ul>
<p>The [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-10">Unforgeable</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-15">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-11">Unforgeable</a></code>]
extended attribute must not appear on
anything other than an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-61">attribute</a>,
non-<a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-12">static</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-62">operation</a> or an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-78">interface</a>. If it does
appear on an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-63">operation</a>, then
it must appear on all operations with
the same <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-54">identifier</a> on that interface.</p>
<p>If an attribute or operation <var>X</var> is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-1">unforgeable</a> on an interface <var>A</var>, and <var>A</var> is one of the <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-15">inherited interfaces</a> of another interface <var>B</var>, then <var>B</var> and all of its <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-20">consequential interfaces</a> must not have a non-static attribute or <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-11">regular operation</a> with the same <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-55">identifier</a> as <var>X</var>.</p>
<div class="note" role="note">
<p>For example, the following is disallowed:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A1</span> {
[<span class="nv">Unforgeable</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">x</span>;
};
<span class="kt">interface</span> <span class="nv">B1</span> : <span class="n">A1</span> {
<span class="kt">void</span> <span class="nv">x</span>(); // Invalid; would be shadowed by A1’s x.
};
<span class="kt">interface</span> <span class="nv">B2</span> : <span class="n">A1</span> { };
<span class="n">B2</span> <span class="kt">implements</span> <span class="n">Mixin</span>;
<span class="kt">interface</span> <span class="nv">Mixin</span> {
<span class="kt">void</span> <span class="nv">x</span>(); // Invalid; B2’s copy of x would be shadowed by A1’s x.
};
[<span class="nv">Unforgeable</span>]
<span class="kt">interface</span> <span class="nv">A2</span> {
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">x</span>;
};
<span class="kt">interface</span> <span class="nv">B3</span> : <span class="n">A2</span> {
<span class="kt">void</span> <span class="nv">x</span>(); // Invalid; would be shadowed by A2’s x.
};
<span class="kt">interface</span> <span class="nv">B4</span> : <span class="n">A2</span> { };
<span class="n">B4</span> <span class="kt">implements</span> <span class="n">Mixin</span>;
<span class="kt">interface</span> <span class="nv">Mixin</span> {
<span class="kt">void</span> <span class="nv">x</span>(); // Invalid; B4’s copy of x would be shadowed by A2’s x.
};
<span class="kt">interface</span> <span class="nv">A3</span> { };
<span class="n">A3</span> <span class="kt">implements</span> <span class="n">A2</span>;
<span class="kt">interface</span> <span class="nv">B5</span> : <span class="n">A3</span> {
<span class="kt">void</span> <span class="nv">x</span>(); // Invalid; would be shadowed by A3’s mixed-in copy of A2’s x.
};
</pre>
</div>
<p>See <a href="#es-attributes">§3.6.6 Attributes</a>, <a href="#es-operations">§3.6.7 Operations</a>, <a href="#es-platform-objects">§3.8 Platform objects implementing interfaces</a>, <a href="#indexed-and-named-properties">§3.8.1 Indexed and named properties</a> and <a href="#defineownproperty">§3.8.7 Platform object [[DefineOwnProperty]] method</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-12">Unforgeable</a></code>] entails.</p>
<div class="example" id="example-8fe6c799">
<a class="self-link" href="#example-8fe6c799"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-44">IDL fragment</a> defines
an interface that has two <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-62">attributes</a>,
one of which is designated as [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-13">Unforgeable</a></code>]:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">System</span> {
[<span class="nv">Unforgeable</span>] <span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">username</span>;
<span class="kt">readonly</span> <span class="kt">attribute</span> <span class="kt">long</span> <span class="kt">long</span> <span class="nv">loginTime</span>;
};
</pre>
<p>In an ECMAScript implementation of the interface, the username attribute will be exposed as a non-configurable property on the
object itself:</p>
<pre class="highlight"><span class="kd">var</span> system <span class="o">=</span> getSystem<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Get an instance of System.
</span>
system<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"username"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to true.
</span>system<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"loginTime"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to false.
</span>System<span class="p">.</span>prototype<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"username"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to false.
</span>System<span class="p">.</span>prototype<span class="p">.</span>hasOwnProperty<span class="p">(</span><span class="s2">"loginTime"</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Evaluates to true.
</span>
<span class="k">try</span> <span class="p">{</span>
<span class="c1">// This call would fail, since the property is non-configurable.
</span> Object<span class="p">.</span>defineProperty<span class="p">(</span>system<span class="p">,</span> <span class="s2">"username"</span><span class="p">,</span> <span class="p">{</span> value<span class="o">:</span> <span class="s2">"administrator"</span> <span class="p">}</span><span class="p">)</span><span class="p">;</span>
<span class="p">}</span> <span class="k">catch</span> <span class="p">(</span>e<span class="p">)</span> <span class="p">{</span> <span class="p">}</span>
<span class="c1">// This defineProperty call would succeed, because System.prototype.loginTime
</span><span class="c1">// is configurable.
</span><span class="kd">var</span> forgedLoginTime <span class="o">=</span> <span class="mi">5</span><span class="p">;</span>
Object<span class="p">.</span>defineProperty<span class="p">(</span>System<span class="p">.</span>prototype<span class="p">,</span> <span class="s2">"loginTime"</span><span class="p">,</span> <span class="p">{</span> value<span class="o">:</span> forgedLoginTime <span class="p">}</span><span class="p">)</span><span class="p">;</span>
system<span class="p">.</span>loginTime<span class="p">;</span> <span class="c1">// So this now evaluates to forgedLoginTime.
</span></pre>
</div>
<h4 class="heading settled dfn-paneled idl-code" data-dfn-type="extended-attribute" data-export="" data-level="3.3.21" data-lt="Unscopable" id="Unscopable"><span class="secno">3.3.21. </span><span class="content">[Unscopable]</span></h4>
<p>If the [<code class="idl"><a data-link-type="idl" href="#Unscopable" id="ref-for-Unscopable-1">Unscopable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-81">extended attribute</a> appears on a <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-10">regular attribute</a> or <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-12">regular operation</a>, it
indicates that an object that implements an interface with the given
interface member will not include its property name in any object
environment record with it as its base object. The result of this is
that bare identifiers matching the property name will not resolve to
the property in a <code>with</code> statement. This is achieved by
including the property name on the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-7">interface prototype object</a>’s <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@unscopables</a> property’s value.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Unscopable" id="ref-for-Unscopable-2">Unscopable</a></code>]
extended attribute must <a data-link-type="dfn" href="#dfn-xattr-no-arguments" id="ref-for-dfn-xattr-no-arguments-16">take no arguments</a>.</p>
<p>The [<code class="idl"><a data-link-type="idl" href="#Unscopable" id="ref-for-Unscopable-3">Unscopable</a></code>]
extended attribute must not appear on
anything other than a <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-11">regular attribute</a> or <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-13">regular operation</a>.</p>
<p>See <a href="#interface-prototype-object">§3.6.3 Interface prototype object</a> for the specific requirements that the use of
[<code class="idl"><a data-link-type="idl" href="#Unscopable" id="ref-for-Unscopable-4">Unscopable</a></code>] entails.</p>
<div class="note" role="note">
<p>For example, with the following IDL:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Thing</span> {
<span class="kt">void</span> <span class="nv">f</span>();
[<span class="nv">Unscopable</span>] <span class="n">g</span>();
};
</pre>
<p>the “f” property an be referenced with a bare identifier
in a <code>with</code> statement but the “g” property cannot:</p>
<pre class="highlight"><span class="kd">var</span> thing <span class="o">=</span> getThing<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// An instance of Thing
</span><span class="kd">with</span> <span class="p">(</span>thing<span class="p">)</span> <span class="p">{</span>
f<span class="p">;</span> <span class="c1">// Evaluates to a Function object.
</span> g<span class="p">;</span> <span class="c1">// Throws a ReferenceError.
</span><span class="p">}</span>
</pre>
</div>
<h3 class="heading settled" data-level="3.4" id="es-security"><span class="secno">3.4. </span><span class="content">Security</span><a class="self-link" href="#es-security"></a></h3>
<p>Certain algorithms in the sections below are defined to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-perform-a-security-check">perform a security check</dfn> on a given
object. This check is used to determine whether a given <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-64">operation</a> invocation or <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-63">attribute</a> access should be
allowed. The security check takes the following four inputs:</p>
<ol>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-18">platform object</a> on
which the operation invocation or attribute access is being done,</p>
<li data-md="">
<p>the ECMAScript global environment associated with the <emu-val>Function</emu-val> object that implements the
operation or attribute,</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-56">identifier</a> of the operation or attribute, and</p>
<li data-md="">
<p>the type of the <emu-val>Function</emu-val> object –
“method” (when it corresponds to an IDL operation), or
“getter” or “setter” (when it corresponds to the
getter or setter function of an IDL attribute).</p>
</ol>
<p class="note" role="note">Note: The expectation is that the HTML specification defines how a
security check is performed, and that it will either throw an
appropriate exception or return normally. <a data-link-type="biblio" href="#biblio-html">[HTML]</a></p>
<h3 class="heading settled" data-level="3.5" id="es-overloads"><span class="secno">3.5. </span><span class="content">Overload resolution algorithm</span><a class="self-link" href="#es-overloads"></a></h3>
<p>In order to define how overloaded function invocations are resolved, the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-overload-resolution-algorithm">overload resolution algorithm</dfn> is defined. Its input is an <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-4">effective overload set</a>, <var>S</var>, and a list of ECMAScript values, <var>arg</var><sub>0..<var>n</var>−1</sub>.
Its output is a pair consisting of the <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-65">operation</a> or <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-82">extended attribute</a> of one of <var>S</var>’s entries
and a list of IDL values or the special value “missing”. The algorithm behaves as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>maxarg</var> be the length of the longest type list of the entries in <var>S</var>.</p>
<li data-md="">
<p>Initialize <var>argcount</var> to be min(<var>maxarg</var>, <var>n</var>).</p>
<li data-md="">
<p>Remove from <var>S</var> all entries whose type list is not of length <var>argcount</var>.</p>
<li data-md="">
<p>If <var>S</var> is empty, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-41">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Initialize <var>d</var> to −1.</p>
<li data-md="">
<p>Initialize <var>method</var> to <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>If there is more than one entry in <var>S</var>, then set <var>d</var> to be the <a data-link-type="dfn" href="#dfn-distinguishing-argument-index" id="ref-for-dfn-distinguishing-argument-index-4">distinguishing argument index</a> for the entries of <var>S</var>.</p>
<li data-md="">
<p>Initialize <var>values</var> to be an empty list, where each entry will be either an IDL value or the special value “missing”.</p>
<li data-md="">
<p>Initialize <var>i</var> to 0.</p>
<li data-md="">
<p>While <var>i</var> < <var>d</var>:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be <var>arg</var><sub><var>i</var></sub>.</p>
<li data-md="">
<p>Let <var>type</var> be the type at index <var>i</var> in the type list of any entry in <var>S</var>.</p>
<p class="note" role="note">Note: All entries in <var>S</var> at this point have the same type and <a data-link-type="dfn" href="#dfn-optionality-value" id="ref-for-dfn-optionality-value-3">optionality value</a> at index <var>i</var>.</p>
<li data-md="">
<p>Let <var>optionality</var> be the value at index <var>i</var> in the list of <a data-link-type="dfn" href="#dfn-optionality-value" id="ref-for-dfn-optionality-value-4">optionality values</a> of any entry in <var>S</var>.</p>
<li data-md="">
<p>If <var>optionality</var> is “optional” and <var>V</var> is <emu-val>undefined</emu-val>, then:</p>
<ol>
<li data-md="">
<p>If the argument at index <var>i</var> is declared with a <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-9">default value</a>,
then append to <var>values</var> that default value.</p>
<li data-md="">
<p>Otherwise, append to <var>values</var> the special value “missing”.</p>
</ol>
<li data-md="">
<p>Otherwise, append to <var>values</var> the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-59">converting</a> <var>V</var> to IDL type <var>type</var>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>If <var>i</var> = <var>d</var>, then:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be <var>arg</var><sub><var>i</var></sub>.</p>
<p class="note" role="note">Note: This is the argument that will be used to resolve which overload is selected.</p>
<li data-md="">
<p>If <var>V</var> is <emu-val>undefined</emu-val>, and there is an entry in <var>S</var> whose list of <a data-link-type="dfn" href="#dfn-optionality-value" id="ref-for-dfn-optionality-value-5">optionality values</a> has “optional” at index <var>i</var>,
then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is <emu-val>null</emu-val> or <emu-val>undefined</emu-val>,
and there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-26">nullable type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-10">dictionary type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-27">union type</a> that <a data-link-type="dfn" href="#dfn-includes-a-nullable-type" id="ref-for-dfn-includes-a-nullable-type-4">includes a nullable type</a> or that
has a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-11">dictionary type</a> in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-10">flattened members</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-19">platform object</a>, and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>an <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-15">interface type</a> that <var>V</var> implements</p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-26">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-27">nullable</a> version of any of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-28">union type</a> or a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-28">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-11">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is a <emu-val>RegExp</emu-val> object and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-RegExp" id="ref-for-idl-RegExp-11">RegExp</a></code></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-27">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-29">nullable</a> version of either of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-29">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-30">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-12">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-26">DOMException</a></code> platform object and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-27">DOMException</a></code></p>
<li data-md="">
<p><code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-15">Error</a></code></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-28">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-31">nullable</a> version of either of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-30">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-32">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-13">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is an <emu-val>Error</emu-val> object (that is, it has an [[ErrorData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>) and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a class="idl-code" data-link-type="interface" href="#idl-Error" id="ref-for-idl-Error-16">Error</a></code></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-29">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-33">nullable</a> version of either of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-31">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-34">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-14">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is an object with an [[ArrayBufferData]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-17">ArrayBuffer</a></code></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-30">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-35">nullable</a> version of either of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-32">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-36">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-15">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is an object with a [[DataView]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-DataView" id="ref-for-idl-DataView-6">DataView</a></code></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-31">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-37">nullable</a> version of either of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-33">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-38">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-16">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is an object with a [[TypedArrayName]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-typed-array-type" id="ref-for-dfn-typed-array-type-3">typed array type</a> whose name
is equal to the value of <var>V</var>’s [[TypedArrayName]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-32">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-39">nullable</a> version of either of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-34">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-40">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-17">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>V</var>) is true,
and there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-27">callback function</a> type</p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-33">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-41">nullable</a> version of any of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-35">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-42">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-18">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is any kind of object except for
a native <emu-val>RegExp</emu-val> object, and
there is an entry in <var>S</var> that has one of the
following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-18">sequence type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-frozen-array-type" id="ref-for-dfn-frozen-array-type-4">frozen array type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-43">nullable</a> version of any of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-36">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-44">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-19">flattened member types</a></p>
</ul>
<p>and after performing the following steps,</p>
<ol>
<li data-md="">
<p>Let <var>method</var> be the result of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-getmethod">GetMethod</a>(<var>V</var>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>method</var>).</p>
</ol>
<p><var>method</var> is not <emu-val>undefined</emu-val>, then remove from <var>S</var> all
other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is any kind of object except for
a native <emu-val>RegExp</emu-val> object, and
there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-24">callback interface</a> type</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#idl-dictionary" id="ref-for-idl-dictionary-12">dictionary type</a></p>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-object" id="ref-for-idl-object-34">object</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-45">nullable</a> version of any of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-37">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-46">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-20">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is a <emu-val>Boolean</emu-val> value,
and there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-19">boolean</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-47">nullable</a> <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-20">boolean</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-38">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-48">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-21">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if <var>V</var> is a <emu-val>Number</emu-val> value,
and there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-6">numeric type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-49">nullable</a> <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-7">numeric type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-39">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-50">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-22">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-string-type" id="ref-for-dfn-string-type-3">string type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-51">nullable</a> version of any of the above types</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-40">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-52">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-23">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-8">numeric type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-53">nullable</a> <a data-link-type="dfn" href="#dfn-numeric-type" id="ref-for-dfn-numeric-type-9">numeric type</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-41">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-54">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-24">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if there is an entry in <var>S</var> that has one of the following types at position <var>i</var> of its type list,</p>
<ul>
<li data-md="">
<p><code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-21">boolean</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-55">nullable</a> <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-22">boolean</a></code></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-union-type" id="ref-for-dfn-union-type-42">union type</a> or <a data-link-type="dfn" href="#dfn-nullable-type" id="ref-for-dfn-nullable-type-56">nullable</a> union type
that has one of the above types in its <a data-link-type="dfn" href="#dfn-flattened-union-member-types" id="ref-for-dfn-flattened-union-member-types-25">flattened member types</a></p>
</ul>
<p>then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: if there is an entry in <var>S</var> that has <code class="idl"><a data-link-type="idl" href="#idl-any" id="ref-for-idl-any-14">any</a></code> at position <var>i</var> of its type list, then remove from <var>S</var> all other entries.</p>
<li data-md="">
<p>Otherwise: <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-42">throw a <emu-val>TypeError</emu-val></a>.</p>
</ol>
<li data-md="">
<p>Let <var>callable</var> be the <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-66">operation</a> or <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-83">extended attribute</a> of the single entry in <var>S</var>.</p>
<li data-md="">
<p>If <var>i</var> = <var>d</var> and <var>method</var> is not <emu-val>undefined</emu-val>, then</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be <var>arg</var><sub><var>i</var></sub>.</p>
<li data-md="">
<p>Let <var>T</var> be the type at index <var>i</var> in the
type list of the remaining entry in <var>S</var>.</p>
<li data-md="">
<p>If <var>T</var> is a <a data-link-type="dfn" href="#sequence-type" id="ref-for-sequence-type-19">sequence type</a>, then
append to <var>values</var> the result of <a data-link-type="dfn" href="#create-sequence-from-iterable" id="ref-for-create-sequence-from-iterable-4">creating a sequence</a> of type <var>T</var> from <var>V</var> and <var>method</var>.</p>
<li data-md="">
<p>Otherwise, <var>T</var> is a <a data-link-type="dfn" href="#dfn-frozen-array-type" id="ref-for-dfn-frozen-array-type-5">frozen array type</a>.
Append to <var>values</var> the result of <a data-link-type="dfn" href="#create-frozen-array-from-iterable" id="ref-for-create-frozen-array-from-iterable-2">creating a frozen array of type T from V and method</a>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>While <var>i</var> < <var>argcount</var>:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be <var>arg</var><sub><var>i</var></sub>.</p>
<li data-md="">
<p>Let <var>type</var> be the type at index <var>i</var> in the type list of the remaining entry in <var>S</var>.</p>
<li data-md="">
<p>Let <var>optionality</var> be the value at index <var>i</var> in the list of <a data-link-type="dfn" href="#dfn-optionality-value" id="ref-for-dfn-optionality-value-6">optionality values</a> of the remaining entry in <var>S</var>.</p>
<li data-md="">
<p>If <var>optionality</var> is “optional” and <var>V</var> is <emu-val>undefined</emu-val>, then:</p>
<ol>
<li data-md="">
<p>If the argument at index <var>i</var> is declared with a <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-10">default value</a>,
then append to <var>values</var> that default value.</p>
<li data-md="">
<p>Otherwise, append to <var>values</var> the special value “missing”.</p>
</ol>
<li data-md="">
<p>Otherwise, append to <var>values</var> the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-60">converting</a> <var>V</var> to IDL type <var>type</var>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>While <var>i</var> is less than the number of arguments <var>callable</var> is declared to take:</p>
<ol>
<li data-md="">
<p>If <var>callable</var>’s argument at index <var>i</var> is declared with a <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-11">default value</a>,
then append to <var>values</var> that default value.</p>
<li data-md="">
<p>Otherwise, if <var>callable</var>’s argument at index <var>i</var> is not variadic, then append to <var>values</var> the special value “missing”.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Return the pair <<var>callable</var>, <var>values</var>>.</p>
</ol>
<div class="note" role="note">
<p>The overload resolution algorithm performs both the identification
of which overloaded operation, constructor, etc. is being called,
and the conversion of the ECMAScript argument values to their
corresponding IDL values. Informally, it operates as follows.</p>
<p>First, the selection of valid overloads is done by considering
the number of ECMAScript arguments that were passed in to the function:</p>
<ul>
<li data-md="">
<p>If there are more arguments passed in than the longest
overload argument list, then they are ignored.</p>
<li data-md="">
<p>After ignoring these trailing arguments, only overloads
that can take this exact number of arguments are considered.
If there are none, then a <emu-val>TypeError</emu-val> is thrown.</p>
</ul>
<p>Once we have a set of possible overloads with the right number
of arguments, the ECMAScript values are converted from left to right.
The nature of the restrictions on overloading means that if we
have multiple possible overloads at this point, then there will
be one position in the argument list that will be used to
distinguish which overload we will finally select; this is
the <a data-link-type="dfn" href="#dfn-distinguishing-argument-index" id="ref-for-dfn-distinguishing-argument-index-5">distinguishing argument index</a>.</p>
<p>We first convert the arguments to the left of the distinguishing
argument. (There is a requirement that an argument to the left of
the distinguishing argument index has the same type as in the other
overloads, at the same index.) Then we inspect the type of the
ECMAScript value that is passed in at the distinguishing argument
index to determine which IDL type it may correspond to.
This allows us to select the final overload that will
be invoked. If the value passed in is <emu-val>undefined</emu-val> and there is an overload with an optional argument at this position, then
we will choose that overload. If there is no valid overload for the type of
value passed in here, then we throw a <emu-val>TypeError</emu-val>.
The inspection of the value at the distinguishing argument index does not have any side effects;
the only side effects that come from running the overload resolution
algorithm are those that come from converting the ECMAScript values
to IDL values.</p>
<p>At this point, we have determined which overload to use. We now
convert the remaining arguments, from the distinguishing argument onwards,
again ignoring any additional arguments that were ignored due to being passed
after the last possible argument.</p>
<p>When converting an optional argument’s ECMAScript value to its equivalent IDL value, <emu-val>undefined</emu-val> will be converted into
the <a data-link-type="dfn" href="#dfn-optional-argument-default-value" id="ref-for-dfn-optional-argument-default-value-12">optional argument’s default value</a>,
if it has one, or a special value “missing” otherwise.</p>
<p>Optional arguments corresponding to a final, variadic argument do not treat <emu-val>undefined</emu-val> as a special “missing” value, however.
The <emu-val>undefined</emu-val> value is converted to the type
of variadic argument as would be done for a non-optional argument.</p>
</div>
<h3 class="heading settled" data-level="3.6" id="es-interfaces"><span class="secno">3.6. </span><span class="content">Interfaces</span><a class="self-link" href="#es-interfaces"></a></h3>
<p>For every <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-79">interface</a> that
is <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-2">exposed</a> in a given
ECMAScript global environment and:</p>
<ul>
<li data-md="">
<p>is a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-25">callback interface</a> that has <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-21">constants</a> declared on it, or</p>
<li data-md="">
<p>is a non-callback <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-80">interface</a> that is not declared with the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-13">NoInterfaceObject</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-84">extended attribute</a>,</p>
</ul>
<p>a corresponding property must exist on the
ECMAScript environment’s global object.
The name of the property is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-57">identifier</a> of the interface,
and its value is an object called the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-interface-object">interface object</dfn>.</p>
<p>The property has the attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.
The characteristics of an interface object are described in <a href="#interface-object">§3.6.1 Interface object</a>.</p>
<p>In addition, for every [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-16">NamedConstructor</a></code>]
extended attribute on an <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-3">exposed</a> interface, a corresponding property must
exist on the ECMAScript global object. The name of the property is the <emu-t class="symbol"><a href="#prod-identifier">identifier</a></emu-t> that occurs directly after the
“<emu-t>=</emu-t>”, and its value is an object called a <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-named-constructor">named constructor</dfn>, which allows
construction of objects that implement the interface. The property has the
attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.
The characteristics of a named constructor are described in <a href="#named-constructors">§3.6.2 Named constructors</a>.</p>
<h4 class="heading settled" data-level="3.6.1" id="interface-object"><span class="secno">3.6.1. </span><span class="content">Interface object</span><a class="self-link" href="#interface-object"></a></h4>
<p>The interface object for a given non-callback <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-81">interface</a> is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-3">function object</a>.
It has properties that correspond to
the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-22">constants</a> and <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-13">static operations</a> defined on that interface, as described in sections <a href="#es-constants">§3.6.5 Constants</a> and <a href="#es-operations">§3.6.7 Operations</a>.</p>
<p>The [[Prototype]] internal property of
an interface object for a non-callback interface is determined as
follows:</p>
<ol>
<li data-md="">
<p>If the interface inherits from some other interface, the value
of [[Prototype]] is the interface
object for that other interface.</p>
<li data-md="">
<p>If the interface doesn’t inherit from any other interface,
the value of [[Prototype]] is <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-function-prototype-object">%FunctionPrototype%</a>.</p>
</ol>
<p>An interface object for a non-callback interface must have a property named “prototype”
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span> whose value is an object called the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-interface-prototype-object">interface prototype object</dfn>. This object has properties
that correspond to the <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-12">regular attributes</a> and <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-14">regular operations</a> defined on the interface,
and is described in more detail in <a href="#interface-prototype-object">§3.6.3 Interface prototype object</a>.</p>
<p class="note" role="note">Note: Since an interface object for a non-callback interface is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-4">function object</a> the <code>typeof</code> operator will return
"function" when applied to
such an interface object.</p>
<p>The internal [[Prototype]] property
of an interface object for a callback interface must be
the Object.prototype object.</p>
<p class="note" role="note">Note: Remember that interface objects for callback interfaces only exist if they have <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-23">constants</a> declared on them;
when they do exist, they are not <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-5">function objects</a>.</p>
<h5 class="heading settled" data-level="3.6.1.1" id="es-interface-call"><span class="secno">3.6.1.1. </span><span class="content">Interface object [[Call]] method</span><a class="self-link" href="#es-interface-call"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-82">interface</a> is declared with a
[<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-20">Constructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-85">extended attribute</a>,
then the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-7">interface object</a> can be called as a function to create an object that implements that
interface. Interfaces that do not have a constructor will throw
an exception when called as a function.</p>
<p>The internal [[Call]] method
of the interface object behaves as follows, assuming <var>arg</var><sub>0..<var>n</var>−1</sub> is the list
of argument values passed to the constructor, and <var>I</var> is the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-83">interface</a>:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>I</var> was not declared with a [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-21">Constructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-86">extended attribute</a>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-43">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>id</var> be the identifier of interface <var>I</var>.</p>
<li data-md="">
<p>Initialize <var>S</var> to the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-5">effective overload set</a> for constructors with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-58">identifier</a> <var>id</var> on <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-84">interface</a> <var>I</var> and with argument count <var>n</var>.</p>
<li data-md="">
<p>Let <<var>constructor</var>, <var>values</var>> be the result of passing <var>S</var> and <var>arg</var><sub>0..<var>n</var>−1</sub> to the <a data-link-type="dfn" href="#dfn-overload-resolution-algorithm" id="ref-for-dfn-overload-resolution-algorithm-1">overload resolution algorithm</a>.</p>
<li data-md="">
<p>Let <var>R</var> be the result of performing the actions listed in the description of <var>constructor</var> with <var>values</var> as the argument values.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-39">converting</a> <var>R</var> to an ECMAScript <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-16">interface type</a> value <var>I</var>.</p>
</ol>
<p>If the internal [[Call]] method
of the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-8">interface object</a> returns normally, then it must
return an object that implements interface <var>I</var>.
This object also must be
associated with the ECMAScript global environment associated
with the interface object.</p>
<p>Interface objects for non-callback interfaces must have a property named “length”
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> whose value is a <emu-val>Number</emu-val>.
If the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-22">Constructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-87">extended attribute</a> does not appear on the interface definition, then the value is 0.
Otherwise, the value is determined as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>id</var> be the identifier of interface <var>I</var>.</p>
<li data-md="">
<p>Initialize <var>S</var> to the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-6">effective overload set</a> for constructors with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-59">identifier</a> <var>id</var> on <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-85">interface</a> <var>I</var> and with argument count 0.</p>
<li data-md="">
<p>Return the length of the shortest argument list of the entries in <var>S</var>.</p>
</ol>
<p>All interface objects must have a
property named “name” with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> whose value is the identifier of the corresponding interface.</p>
<h5 class="heading settled" data-level="3.6.1.2" id="es-interface-hasinstance"><span class="secno">3.6.1.2. </span><span class="content">Interface object [[HasInstance]] method</span><a class="self-link" href="#es-interface-hasinstance"></a></h5>
<p>The internal [[HasInstance]] method of every <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-9">interface object</a> <var>A</var> must behave as follows,
assuming <var>V</var> is the object
argument passed to [[HasInstance]]:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>V</var> is not an object, return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>Let <var>O</var> be the result of calling the [[Get]] method of <var>A</var> with property name “prototype”.</p>
<li data-md="">
<p>If <var>O</var> is not an object, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-44">throw a <emu-val>TypeError</emu-val></a> exception.</p>
<li data-md="">
<p>If <var>V</var> is a platform object that implements the
interface for which <var>O</var> is the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-8">interface prototype object</a>,
return <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Repeat:</p>
<ol>
<li data-md="">
<p>Set <var>V</var> to the value of the [[Prototype]] internal property of <var>V</var>.</p>
<li data-md="">
<p>If <var>V</var> is <emu-val>null</emu-val>, return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>If <var>O</var> and <var>V</var> refer to the same object,
return <emu-val>true</emu-val>.</p>
</ol>
</ol>
<h4 class="heading settled" data-level="3.6.2" id="named-constructors"><span class="secno">3.6.2. </span><span class="content">Named constructors</span><a class="self-link" href="#named-constructors"></a></h4>
<p>A <a data-link-type="dfn" href="#dfn-named-constructor" id="ref-for-dfn-named-constructor-2">named constructor</a> that exists due to one or more
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-17">NamedConstructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-88">extended attributes</a> with a given <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-60">identifier</a> is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-6">function object</a>.
It must have a [[Call]]
internal property, which allows construction of objects that
implement the interface on which the
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-18">NamedConstructor</a></code>]
extended attributes appear. It behaves as follows, assuming <var>arg</var><sub>0..<var>n</var>−1</sub> is the list
of argument values passed to the constructor, <var>id</var> is the identifier of the constructor specified in the
extended attribute <a data-link-type="dfn" href="#dfn-xattr-named-argument-list" id="ref-for-dfn-xattr-named-argument-list-4">named argument list</a>,
and <var>I</var> is the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-86">interface</a> on which the [<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-19">NamedConstructor</a></code>]
extended attribute appears:</p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>S</var> to the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-7">effective overload set</a> for constructors with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-61">identifier</a> <var>id</var> on <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-87">interface</a> <var>I</var> and with argument count <var>n</var>.</p>
<li data-md="">
<p>Let <<var>constructor</var>, <var>values</var>> be the result of passing <var>S</var> and <var>arg</var><sub>0..<var>n</var>−1</sub> to the <a data-link-type="dfn" href="#dfn-overload-resolution-algorithm" id="ref-for-dfn-overload-resolution-algorithm-2">overload resolution algorithm</a>.</p>
<li data-md="">
<p>Let <var>R</var> be the result of performing the actions listed in the description of <var>constructor</var> with <var>values</var> as the argument values.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-40">converting</a> <var>R</var> to an ECMAScript <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-17">interface type</a> value <var>I</var>.</p>
</ol>
<p>If the internal [[Call]] method
of the <a data-link-type="dfn" href="#dfn-named-constructor" id="ref-for-dfn-named-constructor-3">named constructor</a> returns normally, then it must
return an object that implements interface <var>I</var>.
This object also must be
associated with the ECMAScript global environment associated
with the <a data-link-type="dfn" href="#dfn-named-constructor" id="ref-for-dfn-named-constructor-4">named constructor</a>.</p>
<p>A named constructor must have a property named “length”
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> whose value is a <emu-val>Number</emu-val> determined as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>S</var> to the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-8">effective overload set</a> for constructors with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-62">identifier</a> <var>id</var> on <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-88">interface</a> <var>I</var> and with argument count 0.</p>
<li data-md="">
<p>Return the length of the shortest argument list of the entries in <var>S</var>.</p>
</ol>
<p>A named constructor must have a property named “name”
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> whose value is the identifier used for the named constructor.</p>
<p>A named constructor must also have a property named
“prototype” with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span> whose value is the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-9">interface prototype object</a> for the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-89">interface</a> on which the
[<code class="idl"><a data-link-type="idl" href="#NamedConstructor" id="ref-for-NamedConstructor-20">NamedConstructor</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-89">extended attribute</a> appears.</p>
<h4 class="heading settled" data-level="3.6.3" id="interface-prototype-object"><span class="secno">3.6.3. </span><span class="content">Interface prototype object</span><a class="self-link" href="#interface-prototype-object"></a></h4>
<p>There must exist an <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-10">interface prototype object</a> for every non-callback <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-90">interface</a> defined, regardless of whether the interface was declared with the
[<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-14">NoInterfaceObject</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-90">extended attribute</a>.
The interface prototype object for a particular interface has
properties that correspond to the <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-13">regular attributes</a> and <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-15">regular operations</a> defined on that interface. These properties are described in more detail in
sections <a href="#es-attributes">§3.6.6 Attributes</a> and <a href="#es-operations">§3.6.7 Operations</a>.</p>
<p>As with the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-10">interface object</a>,
the interface prototype object also has properties that correspond to the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-24">constants</a> defined on that
interface, described in <a href="#es-operations">§3.6.7 Operations</a>.</p>
<p>If the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-15">NoInterfaceObject</a></code>]
extended attribute was not specified on the interface, then
the interface prototype object must
also have a property named “constructor” with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> whose value
is a reference to the interface object for the interface.</p>
<p>The <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-11">interface prototype object</a> for a given interface <var>A</var> must have an internal
[[Prototype]] property whose value is returned from
the following steps:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>A</var> is declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-31">Global</a></code>]
or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-32">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-91">extended attribute</a>, and <var>A</var> <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-3">supports named properties</a>, then
return the <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-5">named properties object</a> for <var>A</var>, as defined in <a href="#named-properties-object">§3.6.4 Named properties object</a>.</p>
<li data-md="">
<p>Otherwise, if <var>A</var> is declared to inherit from another
interface, then return the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-12">interface prototype object</a> for the inherited interface.</p>
<li data-md="">
<p>Otherwise, if <var>A</var> is declared with the [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-8">LegacyArrayClass</a></code>]
extended attribute, then return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ArrayPrototype%</a>.</p>
<li data-md="">
<p>Otherwise, return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-object-prototype-object">%ObjectPrototype%</a>.</p>
</ol>
<div class="note" role="note">
<p>The <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-13">interface prototype object</a> of an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-91">interface</a> that is defined with
the [<code class="idl"><a data-link-type="idl" href="#NoInterfaceObject" id="ref-for-NoInterfaceObject-16">NoInterfaceObject</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-92">extended attribute</a> will be accessible if the interface is used as a <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-5">non-supplemental interface</a>.
For example, with the following IDL:</p>
<pre class="highlight">[<span class="nv">NoInterfaceObject</span>]
<span class="kt">interface</span> <span class="nv">Foo</span> {
};
<span class="kt">partial</span> <span class="kt">interface</span> <span class="nv">Window</span> {
<span class="kt">attribute</span> <span class="n">Foo</span> <span class="nv">foo</span>;
};
</pre>
<p>it is not possible to access the interface prototype object through
the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-11">interface object</a> (since it does not exist as <code>window.Foo</code>). However, an instance
of <code class="idl">Foo</code> can expose the interface prototype
object by gettings its internal [[Prototype]]
property value – <code>Object.getPrototypeOf(window.foo)</code> in
this example.</p>
<p>If the interface is used solely as a <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-6">supplemental interface</a>,
then there will be no way to access its interface prototype object, since no
object will have the interface prototype object as its internal
[[Prototype]] property value. In such cases,
it is an acceptable optimization for this object not to exist.</p>
</div>
<p>If the interface or any of its <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-21">consequential interfaces</a> has any <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-19">interface member</a> declared with
the [<code class="idl"><a data-link-type="idl" href="#Unscopable" id="ref-for-Unscopable-5">Unscopable</a></code>] extended attribute,
then there must be a property on the
interface prototype object whose name is the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@unscopables</a> symbol
and whose value is an object created as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>object</var> be a new object created as if by the expression <code>({})</code>.</p>
<li data-md="">
<p>For each of the aforementioned <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-20">interface members</a> declared with the [<code class="idl"><a data-link-type="idl" href="#Unscopable" id="ref-for-Unscopable-6">Unscopable</a></code>] extended attribute,
call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>object</var>,
the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-63">identifier</a> of the
interface member, <emu-val>true</emu-val>).</p>
<li data-md="">
<p>Return <var>object</var>.</p>
</ol>
<p>If the interface is declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-33">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-34">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-93">extended attribute</a>, or the interface is in the set
of <a data-link-type="dfn" href="#dfn-inherited-interfaces" id="ref-for-dfn-inherited-interfaces-16">inherited interfaces</a> for any
other interface that is declared with one of these attributes, then the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-14">interface prototype object</a> must be an <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-immutable-prototype-exotic-objects">immutable prototype exotic object</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-1">class string</a> of an <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-15">interface prototype object</a> is the concatenation of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-92">interface</a>’s <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-64">identifier</a> and the string
“Prototype”.</p>
<h4 class="heading settled" data-level="3.6.4" id="named-properties-object"><span class="secno">3.6.4. </span><span class="content">Named properties object</span><a class="self-link" href="#named-properties-object"></a></h4>
<p>For every <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-93">interface</a> declared with the
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-35">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-36">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-94">extended attribute</a> that <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-4">supports named properties</a>,
there must exist an object known as the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-named-properties-object">named properties object</dfn> for that
interface.</p>
<p>The <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-6">named properties object</a> for a given interface <var>A</var> must have an internal
[[Prototype]] property whose value is returned from
the following steps:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>A</var> is declared to inherit from another interface, then return the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-16">interface prototype object</a> for the inherited interface.</p>
<li data-md="">
<p>Otherwise, if <var>A</var> is declared with the [<code class="idl"><a data-link-type="idl" href="#LegacyArrayClass" id="ref-for-LegacyArrayClass-9">LegacyArrayClass</a></code>]
extended attribute, then return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ArrayPrototype%</a>.</p>
<li data-md="">
<p>Otherwise, return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-object-prototype-object">%ObjectPrototype%</a>.</p>
</ol>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-2">class string</a> of a <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-7">named properties object</a> is the concatenation of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-94">interface</a>’s <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-65">identifier</a> and the string
“Properties”.</p>
<h5 class="heading settled" data-level="3.6.4.1" id="named-properties-object-getownproperty"><span class="secno">3.6.4.1. </span><span class="content">Named properties object [[GetOwnProperty]] method</span><a class="self-link" href="#named-properties-object-getownproperty"></a></h5>
<p>When the [[GetOwnProperty]] internal method of a <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-8">named properties object</a> <var>O</var> is called with property key <var>P</var>, the following steps are
taken:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>A</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-95">interface</a> for the <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-9">named properties object</a> <var>O</var>.</p>
<li data-md="">
<p>Let <var>object</var> be the sole object from <var>O</var>’s ECMAScript global environment that implements <var>A</var>.</p>
<p class="note" role="note">Note: For example, if the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-96">interface</a> is the <code class="idl"><a data-link-type="idl" href="https://html.spec.whatwg.org/multipage/browsers.html#window">Window</a></code> interface,
then the sole object will be this global environment’s window object.</p>
<li data-md="">
<p>If the result of running the <a data-link-type="dfn" href="#dfn-named-property-visibility" id="ref-for-dfn-named-property-visibility-1">named property visibility algorithm</a> with
property name <var>P</var> and object <var>object</var> is true, then:</p>
<ol>
<li data-md="">
<p>Let <var>operation</var> be the operation used to declare the named property getter.</p>
<li data-md="">
<p>Let <var>value</var> be an uninitialized variable.</p>
<li data-md="">
<p>If <var>operation</var> was defined without an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-66">identifier</a>, then
set <var>value</var> to the result of performing the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-determine-the-value-of-a-named-property" id="ref-for-dfn-determine-the-value-of-a-named-property-1">determine the value of a named property</a> with <var>P</var> as the name.</p>
<li data-md="">
<p>Otherwise, <var>operation</var> was defined with an identifier. Set <var>value</var> to the result
of performing the steps listed in the description of <var>operation</var> with <var>P</var> as the only argument value.</p>
<li data-md="">
<p>Let <var>desc</var> be a newly created <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-property-descriptor-specification-type">Property Descriptor</a> with no fields.</p>
<li data-md="">
<p>Set <var>desc</var>.[[Value]] to the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-41">converting</a> <var>value</var> to an ECMAScript value.</p>
<li data-md="">
<p>If <var>A</var> implements an interface with the
[<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-5">LegacyUnenumerableNamedProperties</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-95">extended attribute</a>,
then set <var>desc</var>.[[Enumerable]] to <emu-val>false</emu-val>,
otherwise set it to <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Set <var>desc</var>.[[Writable]] to <emu-val>true</emu-val> and <var>desc</var>.[[Configurable]] to <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Return <var>desc</var>.</p>
</ol>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ordinarygetownproperty">OrdinaryGetOwnProperty</a>(<var>O</var>, <var>P</var>).</p>
</ol>
<h5 class="heading settled" data-level="3.6.4.2" id="named-properties-object-defineownproperty"><span class="secno">3.6.4.2. </span><span class="content">Named properties object [[DefineOwnProperty]] method</span><a class="self-link" href="#named-properties-object-defineownproperty"></a></h5>
<p>When the [[DefineOwnProperty]] internal method of a <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-10">named properties object</a> is
called, the following steps are taken:</p>
<ol class="algorithm">
<li data-md="">
<p>Return <emu-val>false</emu-val>.</p>
</ol>
<h5 class="heading settled" data-level="3.6.4.3" id="named-properties-object-delete"><span class="secno">3.6.4.3. </span><span class="content">Named properties object [[Delete]] method</span><a class="self-link" href="#named-properties-object-delete"></a></h5>
<p>When the [[Delete]] internal method of a <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-11">named properties object</a> is called, the
following steps are taken:</p>
<ol class="algorithm">
<li data-md="">
<p>Return <emu-val>false</emu-val>.</p>
</ol>
<h5 class="heading settled" data-level="3.6.4.4" id="named-properties-object-setprototypeof"><span class="secno">3.6.4.4. </span><span class="content">Named properties object [[SetPrototypeOf]] method</span><a class="self-link" href="#named-properties-object-setprototypeof"></a></h5>
<p>When the [[SetPrototypeOf]] internal method of a <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-12">named properties object</a> is
called, the same algorithm must be executed as is defined for the [[SetPrototypeOf]] internal method of an <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-immutable-prototype-exotic-objects">immutable prototype exotic object</a>.</p>
<h4 class="heading settled" data-level="3.6.5" id="es-constants"><span class="secno">3.6.5. </span><span class="content">Constants</span><a class="self-link" href="#es-constants"></a></h4>
<p>For each <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-4">exposed</a> <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-25">constant</a> defined on
an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-97">interface</a> <var>A</var>, there
must be a corresponding property.
The property has the following characteristics:</p>
<ul>
<li data-md="">
<p>The name of the property is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-67">identifier</a> of the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-26">constant</a>.</p>
<li data-md="">
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-37">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-38">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-22">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-39">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-40">PrimaryGlobal</a></code>] annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-41">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-42">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-17">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-18">interface prototype object</a>.</p>
</ul>
<li data-md="">
<p>The value of the property is that which is obtained by <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-42">converting</a> the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-27">constant</a>’s IDL value to an ECMAScript value.</p>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span>.</p>
</ul>
<p>In addition, a property with the same characteristics must
exist on the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-12">interface object</a>, if
that object exists.</p>
<h4 class="heading settled" data-level="3.6.6" id="es-attributes"><span class="secno">3.6.6. </span><span class="content">Attributes</span><a class="self-link" href="#es-attributes"></a></h4>
<p>For each <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-5">exposed</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-64">attribute</a> of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-98">interface</a>, whether it
was declared on the interface itself or one of its <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-23">consequential interfaces</a>,
there must exist a corresponding property.
The characteristics of this property are as follows:</p>
<ul>
<li data-md="">
<p>The name of the property is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-68">identifier</a> of the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-65">attribute</a>.</p>
<li data-md="">
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the attribute is a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-12">static attribute</a>,
then there is a single corresponding property and it exists on the interface’s <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-13">interface object</a>.</p>
<li data-md="">
<p>Otherwise, if the attribute is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-2">unforgeable</a> on
the interface or if the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-43">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-44">PrimaryGlobal</a></code>] extended attribute,
then the property exists on every object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-24">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-45">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-46">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-47">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-48">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-19">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-20">interface prototype object</a>.</p>
</ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Get]]: <var>G</var>, [[Set]]: <var>S</var>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <var>configurable</var> }</span>,
where:</p>
<ul>
<li data-md="">
<p><var>configurable</var> is <emu-val>false</emu-val> if the attribute was
declared with the [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-14">Unforgeable</a></code>] extended attribute and <emu-val>true</emu-val> otherwise;</p>
<li data-md="">
<p><var>G</var> is the <a data-link-type="dfn" href="#dfn-attribute-getter" id="ref-for-dfn-attribute-getter-2">attribute getter</a>, defined below; and</p>
<li data-md="">
<p><var>S</var> is the <a data-link-type="dfn" href="#dfn-attribute-setter" id="ref-for-dfn-attribute-setter-2">attribute setter</a>, also defined below.</p>
</ul>
<li data-md="">
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-attribute-getter">attribute getter</dfn> is a <emu-val>Function</emu-val> object whose behavior when invoked is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>idlValue</var> be an IDL value determined as follows.</p>
<li data-md="">
<p>If the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-66">attribute</a> is a <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-14">regular attribute</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>I</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-99">interface</a> whose <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-21">interface prototype object</a> this property corresponding to the attribute appears on.</p>
<p class="note" role="note">Note: This means that even if an implements statement was used to make
an attribute available on the interface, <var>I</var> is the interface
on the left hand side of the implements statement, and not the one
that the attribute was originally declared on.</p>
<li data-md="">
<p>Let <var>O</var> be the <strong>this</strong> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-20">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-1">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val> that
implements the <a data-link-type="dfn" href="#dfn-attribute-getter" id="ref-for-dfn-attribute-getter-3">attribute getter</a>,</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-69">identifier</a> of the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-67">attribute</a>, and</p>
<li data-md="">
<p>the type “getter”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-21">platform object</a> that implements <var>I</var>, then:</p>
<ol>
<li data-md="">
<p>If the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-68">attribute</a> was specified with the
[<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-8">LenientThis</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-96">extended attribute</a>,
then return <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>Otherwise, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-45">throw a <emu-val>TypeError</emu-val></a>.</p>
</ol>
<li data-md="">
<p>Set <var>idlValue</var> to be the result of performing the actions listed in the description of the attribute that occur when getting
(or those listed in the description of the inherited attribute, if this attribute is declared to <a data-link-type="dfn" href="#dfn-inherit-getter" id="ref-for-dfn-inherit-getter-2">inherit its getter</a>),
with <var>O</var> as the object.</p>
</ol>
<li data-md="">
<p>Otherwise, the attribute is a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-13">static attribute</a>.
Set <var>idlValue</var> to be the result of performing the actions listed in the description of the attribute that occur when getting.</p>
<li data-md="">
<p>Let <var>V</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-43">converting</a> <var>idlValue</var> to an ECMAScript value.</p>
<li data-md="">
<p>Return <var>V</var>.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name”
property is a <emu-val>String</emu-val> whose value is the
concatenation of “get ” and the identifier of the attribute.</p>
<li data-md="">
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-attribute-setter">attribute setter</dfn> is <emu-val>undefined</emu-val> if the attribute is declared <code>readonly</code> and does not have a
[<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-9">LenientThis</a></code>], [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-15">PutForwards</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-11">Replaceable</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-97">extended attribute</a> declared on it.
Otherwise, it is a <emu-val>Function</emu-val> object whose behavior when invoked is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>If no arguments were passed to the <emu-val>Function</emu-val>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-46">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>V</var> be the value of the first argument passed to the <emu-val>Function</emu-val>.</p>
<li data-md="">
<p>If the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-69">attribute</a> is a <a data-link-type="dfn" href="#dfn-regular-attribute" id="ref-for-dfn-regular-attribute-15">regular attribute</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>I</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-100">interface</a> whose <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-22">interface prototype object</a> this property corresponding to the attribute appears on.</p>
<li data-md="">
<p>Let <var>O</var> be the <strong>this</strong> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-22">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-2">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val> that
implements the <a data-link-type="dfn" href="#dfn-attribute-setter" id="ref-for-dfn-attribute-setter-3">attribute setter</a>,</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-70">identifier</a> of the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-70">attribute</a>, and</p>
<li data-md="">
<p>the type “setter”.</p>
</ul>
<li data-md="">
<p>Let <var>validThis</var> be <emu-val>true</emu-val> if <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-23">platform object</a> that implements <var>I</var>, or <emu-val>false</emu-val> otherwise.</p>
<li data-md="">
<p>If <var>validThis</var> is <emu-val>false</emu-val> and the <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-71">attribute</a> was not specified with the
[<code class="idl"><a data-link-type="idl" href="#LenientThis" id="ref-for-LenientThis-10">LenientThis</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-98">extended attribute</a>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-47">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>If the attribute is declared with a [<code class="idl"><a data-link-type="idl" href="#Replaceable" id="ref-for-Replaceable-12">Replaceable</a></code>]
extended attribute, then:</p>
<ol>
<li data-md="">
<p>Let <var>P</var> be the identifier of the attribute.</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>O</var>, <var>P</var>, <var>V</var>).</p>
<li data-md="">
<p>Return <emu-val>undefined</emu-val>.</p>
</ol>
<li data-md="">
<p>If <var>validThis</var> is <emu-val>false</emu-val>, then return <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>If the attribute is declared with a [<code class="idl"><a data-link-type="idl" href="#LenientSetter" id="ref-for-LenientSetter-10">LenientSetter</a></code>]
extended attribute, then return <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>If the attribute is declared with a [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-16">PutForwards</a></code>]
extended attribute, then:</p>
<ol>
<li data-md="">
<p>Let <var>Q</var> be the result of calling the [[Get]] method
on <var>O</var> using the identifier of the attribute as the property name.</p>
<li data-md="">
<p>If <var>Q</var> is not an object, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-48">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>A</var> be the attribute identified by the [<code class="idl"><a data-link-type="idl" href="#PutForwards" id="ref-for-PutForwards-17">PutForwards</a></code>] extended attribute.</p>
<li data-md="">
<p>Call the [[Put]] method on <var>Q</var> using the identifier of <var>A</var> as the property name and <var>V</var> as the value.</p>
<li data-md="">
<p>Return <emu-val>undefined</emu-val>.</p>
</ol>
</ol>
<li data-md="">
<p>Let <var>idlValue</var> be an IDL value determined as follows:</p>
<ul>
<li data-md="">
<p>If the type of the attribute is an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-20">enumeration</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>S</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>V</var>).</p>
<li data-md="">
<p>If <var>S</var> is not one of the <a data-link-type="dfn" href="#dfn-enumeration-value" id="ref-for-dfn-enumeration-value-7">enumeration’s values</a>, then return <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>The value of <var>idlValue</var> is the enumeration value equal to <var>S</var>.</p>
</ol>
<li data-md="">
<p>Otherwise, the type of the attribute is not an <a data-link-type="dfn" href="#dfn-enumeration" id="ref-for-dfn-enumeration-21">enumeration</a>.
The value of <var>idlValue</var> is the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-61">converting</a> <var>V</var> to an IDL value.</p>
</ul>
<li data-md="">
<p>If the attribute is a regular attribute, then perform the actions listed in the description of the attribute that occur when setting,
with <var>O</var> as the object and <var>idlValue</var> as the value.</p>
<li data-md="">
<p>Otherwise, the attribute is a <a data-link-type="dfn" href="#dfn-static-attribute" id="ref-for-dfn-static-attribute-14">static attribute</a>.
Perform the actions listed in the description of the attribute that occur when setting with <var>idlValue</var> as the value.</p>
<li data-md="">
<p>Return <emu-val>undefined</emu-val>.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>1</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name”
property is a <emu-val>String</emu-val> whose value is the
concatenation of “set ” and the identifier of the attribute.</p>
</ul>
<p class="note" role="note">Note: Although there is only a single property for an IDL attribute, since
accessor property getters and setters are passed a <emu-val>this</emu-val> value for the object on which property corresponding to the IDL attribute is
accessed, they are able to expose instance-specific data.</p>
<p class="note" role="note">Note: Note that attempting to assign to a property corresponding to a <a data-link-type="dfn" href="#dfn-read-only" id="ref-for-dfn-read-only-14">read only</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-72">attribute</a> results in different behavior depending on whether the script doing so is in strict mode.
When in strict mode, such an assignment will result in a <emu-val>TypeError</emu-val> being thrown. When not in strict mode, the assignment attempt will be ignored.</p>
<h4 class="heading settled" data-level="3.6.7" id="es-operations"><span class="secno">3.6.7. </span><span class="content">Operations</span><a class="self-link" href="#es-operations"></a></h4>
<p>For each unique <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-71">identifier</a> of an <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-6">exposed</a> <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-67">operation</a> defined on the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-101">interface</a>, there
must exist a corresponding property,
unless the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-9">effective overload set</a> for that <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-72">identifier</a> and <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-68">operation</a> and with an argument count of 0 has no entries.</p>
<p>The characteristics of this property are as follows:</p>
<ul>
<li data-md="">
<p>The name of the property is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-73">identifier</a>.</p>
<li data-md="">
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the operation is <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-14">static</a>, then
the property exists on the <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-14">interface object</a>.</p>
<li data-md="">
<p>Otherwise, if the operation is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-3">unforgeable</a> on
the interface or if the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-49">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-50">PrimaryGlobal</a></code>] extended attribute,
then the property exists on every object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-25">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-51">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-52">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-53">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-54">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-23">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-24">interface prototype object</a>.</p>
</ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <var>B</var>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <var>B</var> }</span>,
where <var>B</var> is <emu-val>false</emu-val> if the operation is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-4">unforgeable</a> on the interface,
and <emu-val>true</emu-val> otherwise.</p>
<li data-md="">
<p>The value of the property is the result of <a data-link-type="dfn" href="#dfn-create-operation-function" id="ref-for-dfn-create-operation-function-1">creating an operation function</a> given the
operation, the interface (or the interface it’s being mixed in to, if the interface is actually
a mixin), and the <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-relevant-realm">relevant Realm</a> of the object that is the location of the property.</p>
<p class="note" role="note">Note: that is, even if an <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-7">implements statement</a> was used to make an operation
available on the interface, we pass in the interface on the left-hand side of the <a data-link-type="dfn" href="#dfn-implements-statement" id="ref-for-dfn-implements-statement-8">implements statement</a>, and not the really-a-mixin interface on the right-hand side,
where the operation was originally declared.</p>
</ul>
<p class="advisement"> The above description has some bugs, especially around partial interfaces. See <a href="https://github.com/heycam/webidl/issues/164">issue #164</a>. </p>
<p>For <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-10">namespaces</a>, the properties corresponding to each declared operation are described in <a href="#namespace-object">§3.11.1 Namespace object</a>. (We hope to eventually move interfaces to the same explicit
property-installation style as namespaces.)</p>
<p>To <dfn class="dfn-paneled" data-dfn-type="dfn" data-lt="creating an operation function" data-noexport="" id="dfn-create-operation-function">create an operation function</dfn>,
given an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-69">operation</a> <var>op</var>, a <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-11">namespace</a> or <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-102">interface</a> <var>target</var>, and a <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-code-realms">Realm</a> <var>realm</var>:</p>
<ol>
<li data-md="">
<p>Let <var>id</var> be <var>op</var>’s <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-74">identifier</a>.</p>
<li data-md="">
<p>Let <var>steps</var> be the following series of steps, given function argument
values <var>arg</var><sub>0..<var>n</var>−1</sub>:</p>
<ol>
<li data-md="">
<p>Try running the following steps:</p>
<ol>
<li data-md="">
<p>Let <var>O</var> be <emu-val>null</emu-val>.</p>
<li data-md="">
<p>If <var>target</var> is an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-103">interface</a>, and <var>op</var> is not a <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-15">static operation</a>:</p>
<ol>
<li data-md="">
<p>If the <emu-val>this</emu-val> value is <emu-val>null</emu-val> or <emu-val>undefined</emu-val>, set <var>O</var> to <var>realm</var>’s <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-global">global object</a>. (This
will subsequently cause a <emu-val>TypeError</emu-val> in a few steps, if the global
object does not implement <var>target</var>.)</p>
<li data-md="">
<p>Otherwise, set <var>O</var> to the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-24">platform object</a>, then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-3">perform a security check</a>, passing <var>O</var>, <var>realm</var>, <var>id</var>, and "method".</p>
<li data-md="">
<p>If <var>O</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-25">platform object</a> that implements the interface <var>target</var>, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-49">throw a <emu-val>TypeError</emu-val></a>.</p>
</ol>
<li data-md="">
<p>Let <var>S</var> be the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-10">effective overload set</a> for <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-16">regular operations</a> (if <var>op</var> is a
regular operation) or for <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-16">static operations</a> (if <var>op</var> is a static operation) with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-75">identifier</a> <var>id</var> on <var>target</var> and with argument count <var>n</var>.</p>
<li data-md="">
<p>Let <<var>operation</var>, <var>values</var>> be the result of passing <var>S</var> and <var>arg</var><sub>0..<var>n</var>−1</sub> to the <a data-link-type="dfn" href="#dfn-overload-resolution-algorithm" id="ref-for-dfn-overload-resolution-algorithm-3">overload resolution algorithm</a>.</p>
<li data-md="">
<p>Let <var>R</var> be the result of performing the actions listed in the
description of <var>operation</var>, on <var>O</var> if <var>O</var> is not <emu-val>null</emu-val>, with <var>values</var> as the argument values.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-44">converting</a> <var>R</var> to
an ECMAScript value of the type <var>op</var> is declared to return.</p>
</ol>
</ol>
<p>And then, if an exception was thrown:</p>
<ol>
<li data-md="">
<p>If the operation has a <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-5">return type</a> that is a <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-8">promise type</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>reject</var> be the initial value of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a>.reject.</p>
<li data-md="">
<p>Return the result of calling <var>reject</var> with <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a> as the <emu-val>this</emu-val> object
and the exception as the single argument value.</p>
</ol>
<li data-md="">
<p>Otherwise, end these steps and allow the exception to propagate.</p>
</ol>
<li data-md="">
<p>Let <var>F</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createbuiltinfunction">CreateBuiltinFunction</a>(<var>realm</var>, <var>steps</var>, the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-function-prototype-object">%FunctionPrototype%</a> of <var>realm</var>).</p>
<li data-md="">
<p>Perform <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-setfunctionname">SetFunctionName</a>(<var>F</var>, <var>id</var>).</p>
<li data-md="">
<p>Let <var>S</var> be the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-11">effective overload set</a> for <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-17">regular operations</a> (if <var>op</var> is a regular
operation) or for <a data-link-type="dfn" href="#dfn-static-operation" id="ref-for-dfn-static-operation-17">static operations</a> (if <var>op</var> is a static operation) with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-76">identifier</a> <var>id</var> on <var>target</var> and with argument count 0.</p>
<li data-md="">
<p>Let <var>length</var> be the length of the shortest argument list in the entries in <var>S</var>.</p>
<li data-md="">
<p>Perform <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-definepropertyorthrow">DefinePropertyOrThrow</a>(<var>F</var>, "length",
PropertyDescriptor<span class="descriptor">{[[Value]]: <var>length</var>,
[[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val>}</span>).</p>
</ol>
<h5 class="heading settled" data-level="3.6.7.1" id="es-stringifier"><span class="secno">3.6.7.1. </span><span class="content">Stringifiers</span><a class="self-link" href="#es-stringifier"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-104">interface</a> has an <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-7">exposed</a> <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-3">stringifier</a>, then
there must exist a property with
the following characteristics:</p>
<ul>
<li data-md="">
<p>The name of the property is “toString”.</p>
<li data-md="">
<p>If the <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-4">stringifier</a> is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-5">unforgeable</a> on the interface
or if the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-55">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-56">PrimaryGlobal</a></code>] extended attribute,
then the property exists on every object that implements the interface.
Otherwise, the property exists on the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-25">interface prototype object</a>.</p>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <var>B</var>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <var>B</var> }</span>,
where <var>B</var> is <emu-val>false</emu-val> if the stringifier is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-6">unforgeable</a> on the interface,
and <emu-val>true</emu-val> otherwise.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object, which behaves as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-26">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-4">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val> that
implements the <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-5">stringifier</a>,</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-77">identifier</a> of the <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-6">stringifier</a>, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-105">interface</a> on which the stringifier was declared, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-50">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>V</var> be an uninitialized variable.</p>
<li data-md="">
<p>Depending on where <code>stringifier</code> was specified:</p>
<dl class="switch">
<dt data-md="">
<p>on an <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-73">attribute</a></p>
<dd data-md="">
<p>Set <var>V</var> to the result of performing the actions listed in the description of the attribute that occur when getting
(or those listed in the description of the inherited attribute, if this attribute is declared to <a data-link-type="dfn" href="#dfn-inherit-getter" id="ref-for-dfn-inherit-getter-3">inherit its getter</a>),
with <var>O</var> as the object.</p>
<dt data-md="">
<p>on an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-70">operation</a> with an identifier</p>
<dd data-md="">
<p>Set <var>V</var> to the result of performing the actions listed in the description
of the operation, using <var>O</var> as the <emu-val>this</emu-val> value
and passing no arguments.</p>
<dt data-md="">
<p>on an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-71">operation</a> with no identifier</p>
<dd data-md="">
<p>Set <var>V</var> to the result of performing the <a data-link-type="dfn" href="#dfn-stringification-behavior" id="ref-for-dfn-stringification-behavior-1">stringification behavior</a> of the interface.</p>
</dl>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-45">converting</a> <var>V</var> to a <emu-val>String</emu-val> value.</p>
</ol>
<li data-md="">
<p>The value of the <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<li data-md="">
<p>The value of the <emu-val>Function</emu-val> object’s “name”
property is the <emu-val>String</emu-val> value “toString”.</p>
</ul>
<h5 class="heading settled" data-level="3.6.7.2" id="es-serializer"><span class="secno">3.6.7.2. </span><span class="content">Serializers</span><a class="self-link" href="#es-serializer"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-106">interface</a> has an <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-8">exposed</a> <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-5">serializer</a>, then
a property must exist
whose name is “toJSON”,
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <emu-val>Function</emu-val> object.</p>
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-57">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-58">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-26">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-59">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-60">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-61">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-62">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-26">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-27">interface prototype object</a>.</p>
</ul>
<p>The property’s <emu-val>Function</emu-val> object, when invoked,
must behave as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-27">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-5">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val> that
implements the <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-6">serializer</a>,</p>
<li data-md="">
<p>the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-78">identifier</a> of the <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-7">serializer</a>, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-107">interface</a> on which the serializer was declared, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-51">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Depending on how <code>serializer</code> was specified:</p>
<dl class="switch">
<dt data-md="">
<p>on an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-72">operation</a> with an identifier</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Return the result of performing the actions listed in the description of the
operation, using <var>O</var> as the <emu-val>this</emu-val> value
and passing no arguments.</p>
</ol>
<dt data-md="">
<p>as a keyword, either with or without a <a data-link-type="dfn" href="#dfn-serialization-pattern" id="ref-for-dfn-serialization-pattern-4">serialization pattern</a></p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-8">serialized value</a> that is the result of invoking the <a data-link-type="dfn" href="#dfn-serialization-behavior" id="ref-for-dfn-serialization-behavior-15">serialization behavior</a> of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-108">interface</a> for object <var>O</var>.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-serialized-value-to-ecmascript-value" id="ref-for-dfn-convert-serialized-value-to-ecmascript-value-1">converting</a> <var>S</var> to an ECMAScript value.</p>
</ol>
</dl>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name”
property is the <emu-val>String</emu-val> value “toJSON”.</p>
<p>The following steps define how to <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-convert-serialized-value-to-ecmascript-value">convert a serialized value to an ECMAScript value</dfn>:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>S</var> be the <a data-link-type="dfn" href="#dfn-serialized-value" id="ref-for-dfn-serialized-value-9">serialized value</a>.</p>
<li data-md="">
<p>Depending on the type of <var>S</var>:</p>
<dl class="switch">
<dt data-md="">
<p>a map</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be a new object created as if by the expression <code>({})</code>.</p>
<li data-md="">
<p>For each entry in <var>S</var>, in the order they were added to the map:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the result of <a data-link-type="dfn" href="#dfn-convert-serialized-value-to-ecmascript-value" id="ref-for-dfn-convert-serialized-value-to-ecmascript-value-2">converting</a> the value of the entry to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>P</var> be the entry’s key.</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>O</var>, <var>P</var>, <var>V</var>).</p>
</ol>
<li data-md="">
<p>Return <var>O</var>.</p>
</ol>
<dt data-md="">
<p>a list</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>A</var> be a new <emu-val>Array</emu-val> object created as if by the expression <code>[]</code>.</p>
<li data-md="">
<p>Let <var>index</var> be 0.</p>
<li data-md="">
<p>While <var>index</var> is less than the number of elements in <var>S</var>:</p>
<ol>
<li data-md="">
<p>Let <var>V</var> be the result of <a data-link-type="dfn" href="#dfn-convert-serialized-value-to-ecmascript-value" id="ref-for-dfn-convert-serialized-value-to-ecmascript-value-3">converting</a> the value of the element in <var>S</var> at index <var>index</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>P</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>index</var>).</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>O</var>, <var>P</var>, <var>V</var>).</p>
</ol>
<li data-md="">
<p>Return <var>A</var>.</p>
</ol>
<dt data-md="">
<p>any other serialized value</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>V</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-46">converting</a> <var>S</var> to an ECMAScript value.</p>
<li data-md="">
<p>Return <var>V</var>.</p>
</ol>
</dl>
</ol>
<h4 class="heading settled" data-level="3.6.8" id="es-iterators"><span class="secno">3.6.8. </span><span class="content">Common iterator behavior</span><a class="self-link" href="#es-iterators"></a></h4>
<h5 class="heading settled" data-level="3.6.8.1" id="es-iterator"><span class="secno">3.6.8.1. </span><span class="content">@@iterator</span><a class="self-link" href="#es-iterator"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-109">interface</a> has any of the following:</p>
<ul>
<li data-md="">
<p>an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-9">iterable declaration</a></p>
<li data-md="">
<p>an <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-5">indexed property getter</a> and an <a data-link-type="dfn" href="#dfn-integer-type" id="ref-for-dfn-integer-type-6">integer-typed</a> <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-74">attribute</a> named
“length”</p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-7">maplike declaration</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-7">setlike declaration</a></p>
</ul>
<p>then a property must exist
whose name is the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> symbol,
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-7">function object</a>.</p>
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-63">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-64">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-27">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-65">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-66">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-67">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-68">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-28">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-29">interface prototype object</a>.</p>
</ul>
<p>If the interface defines an <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-6">indexed property getter</a>,
then the <emu-val>Function</emu-val> object is <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ArrayProto_values%</a>.</p>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-4">pair iterator</a>,
then the <emu-val>Function</emu-val>, when invoked,
must behave as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>object</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>object</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-28">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-6">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>object</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “@@iterator”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>Let <var>interface</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-110">interface</a> the <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-10">iterable declaration</a> is on.</p>
<li data-md="">
<p>If <var>object</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-29">platform object</a> that implements <var>interface</var>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-52">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>iterator</var> be a newly created <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-1">default iterator object</a> for <var>interface</var> with <var>object</var> as its target and iterator kind “key+value”.</p>
<li data-md="">
<p>Return <var>iterator</var>.</p>
</ol>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-8">maplike declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-8">setlike declaration</a>,
then the <emu-val>Function</emu-val> object that is the value of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> property,
when invoked, must behave as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>object</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>object</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-30">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-7">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>object</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “@@iterator”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>object</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-31">platform object</a> that implements the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-111">interface</a> on which the <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-9">maplike declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-9">setlike declaration</a> is defined,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-53">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>If the interface has a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-10">maplike declaration</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>backing</var> be the value of the [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> of <var>object</var>.</p>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createmapiterator">CreateMapIterator</a>(<var>backing</var>, <code>"key+value"</code>).</p>
</ol>
<li data-md="">
<p>Otherwise:</p>
<ol>
<li data-md="">
<p>Let <var>backing</var> be the value of the [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> of <var>object</var>.</p>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createsetiterator">CreateSetIterator</a>(<var>backing</var>, <code>"value"</code>).</p>
</ol>
</ol>
<p>The value of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> <emu-val>Function</emu-val> object’s “name”
property is the <emu-val>String</emu-val> value “entries” if the interface has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-5">pair iterator</a> or a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-11">maplike declaration</a> and the <emu-val>String</emu-val> “values”
if the interface has a <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-10">setlike declaration</a>.</p>
<h5 class="heading settled" data-level="3.6.8.2" id="es-forEach"><span class="secno">3.6.8.2. </span><span class="content">forEach</span><a class="self-link" href="#es-forEach"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-112">interface</a> has any of the following:</p>
<ul>
<li data-md="">
<p>an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-11">iterable declaration</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-12">maplike declaration</a></p>
<li data-md="">
<p>a <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-11">setlike declaration</a></p>
</ul>
<p>then a property named “forEach” must exist
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-8">function object</a>.</p>
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-69">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-70">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-28">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-71">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-72">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-73">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-74">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-30">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-31">interface prototype object</a>.</p>
</ul>
<p>If the interface defines an <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-7">indexed property getter</a>,
then the <emu-val>Function</emu-val> object is
the initial value of the “forEach” data property of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ArrayPrototype%</a>.</p>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-6">pair iterator</a>,
then the <emu-val>Function</emu-val> must
have the same behavior as one that would exist assuming the interface had
this <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-73">operation</a> instead of the <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-12">iterable declaration</a>:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Iterable</span> {
<span class="kt">void</span> <span class="nv">forEach</span>(<span class="n">Function</span> <span class="nv">callback</span>, <span class="kt">optional</span> <span class="kt">any</span> <span class="nv">thisArg</span>);
};
</pre>
<p>with the following prose definition:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <strong>this</strong> value.</p>
<li data-md="">
<p>Let <var>pairs</var> be the list of <a data-link-type="dfn" href="#dfn-value-pairs-to-iterate-over" id="ref-for-dfn-value-pairs-to-iterate-over-1">value pairs to iterate over</a>.</p>
<li data-md="">
<p>Let <var>i</var> be 0.</p>
<li data-md="">
<p>While <var>i</var> is less than the length of <var>pairs</var>:</p>
<ol>
<li data-md="">
<p>Let <var>pair</var> be the entry in <var>pairs</var> at index <var>i</var>.</p>
<li data-md="">
<p>Let <var>key</var> be <var>pair</var>’s key.</p>
<li data-md="">
<p>Let <var>value</var> be <var>pair</var>’s value.</p>
<li data-md="">
<p><a href="#es-invoking-callback-functions">Invoke</a> <var>callback</var> with <var>thisArg</var> (or <emu-val>undefined</emu-val>, if the argument was not supplied)
as the <a data-link-type="dfn" href="#dfn-callback-this-value" id="ref-for-dfn-callback-this-value-1">callback this value</a> and <var>value</var>, <var>key</var> and <var>O</var> as its arguments.</p>
<li data-md="">
<p>Update <var>pairs</var> to the current list of <a data-link-type="dfn" href="#dfn-value-pairs-to-iterate-over" id="ref-for-dfn-value-pairs-to-iterate-over-2">value pairs to iterate over</a>.</p>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
</ol>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-13">maplike declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-12">setlike declaration</a> then the <emu-val>Function</emu-val>, when invoked,
must behave as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>object</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>object</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-32">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-8">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>object</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “forEach”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>Let <var>interface</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-113">interface</a> on which the <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-14">maplike declaration</a> or <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-13">setlike declaration</a> is declared.</p>
<li data-md="">
<p>If <var>object</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-33">platform object</a> that implements <var>interface</var>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-54">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>callbackFn</var> be the value of the first argument passed to the function, or <emu-val>undefined</emu-val> if the argument was not supplied.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>callbackFn</var>) is <emu-val>false</emu-val>, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-55">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>thisArg</var> be the value of the second argument passed to the function, or <emu-val>undefined</emu-val> if the argument was not supplied.</p>
<li data-md="">
<p>Let <var>backing</var> be the value of the [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> of <var>object</var>,
if the interface has a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-15">maplike declaration</a>,
or the [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a> of <var>object</var> otherwise.</p>
<li data-md="">
<p>Let <var>callbackWrapper</var> be a <emu-val>Function</emu-val> that, when invoked, behaves as follows:</p>
<ol>
<li data-md="">
<p>Let <var>v</var> and <var>k</var> be the first two arguments passed to the function.</p>
<li data-md="">
<p>Let <var>thisArg</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>Call the [[Call]] internal method of <var>callbackFn</var> with <var>thisArg</var> as <var>thisArgument</var> and <var>v</var>, <var>k</var> and <var>object</var> as <var>argumentsList</var>.</p>
</ol>
<p class="note" role="note">Note: The <var>callbackWrapper</var> function simply calls the incoming <var>callbackFn</var> with <var>object</var> as the third argument rather than its internal [[BackingMap]] or [[BackingSet]] object.</p>
<p class="issue" id="issue-32b8bcb1"><a class="self-link" href="#issue-32b8bcb1"></a> Can the script author observe that <var>callbackWrapper</var> might be a new function
every time forEach is called? What’s the best way of specifying that there’s only
one function that has captured an environment? </p>
<li data-md="">
<p>Let <var>forEach</var> be the result of calling the [[Get]] internal method of <var>backing</var> with “forEach” and <var>backing</var> as arguments.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>forEach</var>) is <emu-val>false</emu-val>, <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-56">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Call the [[Call]] internal method of <var>forEach</var> with <var>backing</var> as <var>thisArgument</var> and <var>callbackWrapper</var> and <var>thisArg</var> as <var>argumentsList</var>.</p>
<li data-md="">
<p>Return <emu-val>undefined</emu-val>.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>1</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name”
property is the <emu-val>String</emu-val> value “forEach”.</p>
<h4 class="heading settled" data-level="3.6.9" id="es-iterable"><span class="secno">3.6.9. </span><span class="content">Iterable declarations</span><a class="self-link" href="#es-iterable"></a></h4>
<h5 class="heading settled" data-level="3.6.9.1" id="es-iterable-entries"><span class="secno">3.6.9.1. </span><span class="content">entries</span><a class="self-link" href="#es-iterable-entries"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-114">interface</a> has an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-13">iterable declaration</a>,
then a property named “entries” must exist
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-9">function object</a>.</p>
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-75">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-76">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-29">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-77">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-78">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-79">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-80">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-32">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-33">interface prototype object</a>.</p>
</ul>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-7">value iterator</a>,
then the <emu-val>Function</emu-val> object is
the initial value of the “entries” data property of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ArrayPrototype%</a>.</p>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-7">pair iterator</a>,
then the <emu-val>Function</emu-val> object is
the value of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> property.</p>
<h5 class="heading settled" data-level="3.6.9.2" id="es-iterable-keys"><span class="secno">3.6.9.2. </span><span class="content">keys</span><a class="self-link" href="#es-iterable-keys"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-115">interface</a> has an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-14">iterable declaration</a>,
then a property named “keys” must exist
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-10">function object</a>.</p>
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-81">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-82">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-30">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-83">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-84">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-85">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-86">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-34">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-35">interface prototype object</a>.</p>
</ul>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-8">value iterator</a>,
then the <emu-val>Function</emu-val> object is
the initial value of the “keys” data property of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ArrayPrototype%</a>.</p>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-8">pair iterator</a>,
then the <emu-val>Function</emu-val>, when invoked, must behave as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>object</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>object</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-34">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-9">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>object</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “keys”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>Let <var>interface</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-116">interface</a> on which the <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-15">iterable declaration</a> is declared on.</p>
<li data-md="">
<p>If <var>object</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-35">platform object</a> that implements <var>interface</var>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-57">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>iterator</var> be a newly created <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-2">default iterator object</a> for <var>interface</var> with <var>object</var> as its target and iterator kind “key”.</p>
<li data-md="">
<p>Return <var>iterator</var>.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “keys”.</p>
<h5 class="heading settled" data-level="3.6.9.3" id="es-iterable-values"><span class="secno">3.6.9.3. </span><span class="content">values</span><a class="self-link" href="#es-iterable-values"></a></h5>
<p>If the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-117">interface</a> has an <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-16">iterable declaration</a>,
then a property named “values” must exist
with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-11">function object</a>.</p>
<p>The location of the property is determined as follows:</p>
<ul>
<li data-md="">
<p>If the interface was declared with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-87">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-88">PrimaryGlobal</a></code>] extended attribute,
then the property exists on the single object that implements the interface.</p>
<li data-md="">
<p>Otherwise, if the interface is a <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-31">consequential interface</a> of a [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-89">Global</a></code>]- or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-90">PrimaryGlobal</a></code>]-annotated interface, then
the property exists on the single object that implements the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-91">Global</a></code>]- or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-92">PrimaryGlobal</a></code>]-annotated interface as well as on
the consequential interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-36">interface prototype object</a>.</p>
<li data-md="">
<p>Otherwise, the property exists solely on the interface’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-37">interface prototype object</a>.</p>
</ul>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-9">value iterator</a>,
then the <emu-val>Function</emu-val> object is
the value of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> property.</p>
<p>If the interface has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-9">pair iterator</a>,
then the <emu-val>Function</emu-val>, when invoked, must behave as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>object</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>object</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-36">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-10">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>object</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “entries”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>Let <var>interface</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-118">interface</a> on which the <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-17">iterable declaration</a> is declared on.</p>
<li data-md="">
<p>If <var>object</var> is not a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-37">platform object</a> that implements <var>interface</var>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-58">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>iterator</var> be a newly created <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-3">default iterator object</a> for <var>interface</var> with <var>object</var> as its target and iterator kind “value”.</p>
<li data-md="">
<p>Return <var>iterator</var>.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “values”.</p>
<h5 class="heading settled" data-level="3.6.9.4" id="es-default-iterator-object"><span class="secno">3.6.9.4. </span><span class="content">Default iterator objects</span><a class="self-link" href="#es-default-iterator-object"></a></h5>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-default-iterator-object">default iterator object</dfn> for a given <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-119">interface</a>, target and iteration kind
is an object whose internal [[Prototype]] property is the <a data-link-type="dfn" href="#dfn-iterator-prototype-object" id="ref-for-dfn-iterator-prototype-object-2">iterator prototype object</a> for the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-120">interface</a>.</p>
<p>A <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-4">default iterator object</a> has three internal values:</p>
<ol>
<li data-md="">
<p>its <em>target</em>, which is an object whose values are to be iterated,</p>
<li data-md="">
<p>its <em>kind</em>, which is the iteration kind,</p>
<li data-md="">
<p>its <em>index</em>, which is the current index into the values value to be iterated.</p>
</ol>
<p class="note" role="note">Note: Default iterator objects are only used for <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-10">pair iterators</a>; <a data-link-type="dfn" href="#dfn-value-iterator" id="ref-for-dfn-value-iterator-10">value iterators</a>, as they are currently
restricted to iterating over an object’s <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-8">supported indexed properties</a>,
use standard ECMAScript Array iterator objects.</p>
<p>When a <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-5">default iterator object</a> is first created,
its index is set to 0.</p>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-3">class string</a> of a <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-6">default iterator object</a> for a given <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-121">interface</a> is the result of concatenting the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-79">identifier</a> of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-122">interface</a> and
the string “ Iterator”.</p>
<h5 class="heading settled" data-level="3.6.9.5" id="es-iterator-prototype-object"><span class="secno">3.6.9.5. </span><span class="content">Iterator prototype object</span><a class="self-link" href="#es-iterator-prototype-object"></a></h5>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-iterator-prototype-object">iterator prototype object</dfn> for a given <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-123">interface</a> is an object that exists for every interface that has a <a data-link-type="dfn" href="#dfn-pair-iterator" id="ref-for-dfn-pair-iterator-11">pair iterator</a>. It serves as the
prototype for <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-7">default iterator objects</a> for the interface.</p>
<p>The internal [[Prototype]] property of an <a data-link-type="dfn" href="#dfn-iterator-prototype-object" id="ref-for-dfn-iterator-prototype-object-3">iterator prototype object</a> must be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%IteratorPrototype%</a>.</p>
<p>An <a data-link-type="dfn" href="#dfn-iterator-prototype-object" id="ref-for-dfn-iterator-prototype-object-4">iterator prototype object</a> must have a property named “next” with
attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-12">function object</a> that behaves as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>interface</var> be the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-124">interface</a> for which the <a data-link-type="dfn" href="#dfn-iterator-prototype-object" id="ref-for-dfn-iterator-prototype-object-5">iterator prototype object</a> exists.</p>
<li data-md="">
<p>Let <var>object</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-toobject">ToObject</a> on the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>object</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-38">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-11">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>object</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “next”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>object</var> is not a <a data-link-type="dfn" href="#dfn-default-iterator-object" id="ref-for-dfn-default-iterator-object-8">default iterator object</a> for <var>interface</var>,
then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-59">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>target</var> be <var>object</var>’s target.</p>
<li data-md="">
<p>Let <var>index</var> be <var>object</var>’s index.</p>
<li data-md="">
<p>Let <var>kind</var> be <var>object</var>’s kind.</p>
<li data-md="">
<p>Let <var>values</var> be the list of <a data-link-type="dfn" href="#dfn-value-pairs-to-iterate-over" id="ref-for-dfn-value-pairs-to-iterate-over-3">value pairs to iterate over</a>.</p>
<li data-md="">
<p>Let <var>len</var> be the length of <var>values</var>.</p>
<li data-md="">
<p>If <var>object</var>’s index is greater than or equal to <var>len</var>, then
return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createiterresultobject">CreateIterResultObject</a>(<emu-val>undefined</emu-val>, <emu-val>true</emu-val>).</p>
<li data-md="">
<p>Let <var>pair</var> be the entry in <var>values</var> at index <var>index</var>.</p>
<li data-md="">
<p>Let <var>result</var> be a value determined by the value of <var>kind</var>:</p>
<dl class="switch">
<dt data-md="">
<p>key</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>idlKey</var> be <var>pair</var>’s key.</p>
<li data-md="">
<p>Let <var>key</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-47">converting</a> <var>idlKey</var> to an ECMAScript value.</p>
<li data-md="">
<p><var>result</var> is <var>key</var>.</p>
</ol>
<dt data-md="">
<p>value</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>idlValue</var> be <var>pair</var>’s value.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-48">converting</a> <var>idlValue</var> to an ECMAScript value.</p>
<li data-md="">
<p><var>result</var> is <var>value</var>.</p>
</ol>
<dt data-md="">
<p>key+value</p>
<dd data-md="">
<ol class="algorithm">
<li data-md="">
<p>Let <var>idlKey</var> be <var>pair</var>’s key.</p>
<li data-md="">
<p>Let <var>idlValue</var> be <var>pair</var>’s value.</p>
<li data-md="">
<p>Let <var>key</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-49">converting</a> <var>idlKey</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-50">converting</a> <var>idlValue</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>array</var> be the result of performing <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-arraycreate">ArrayCreate</a>(2).</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>array</var>, "0", <var>key</var>).</p>
<li data-md="">
<p>Call <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>array</var>, "1", <var>value</var>).</p>
<li data-md="">
<p><var>result</var> is <var>array</var>.</p>
</ol>
</dl>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createiterresultobject">CreateIterResultObject</a>(<var>result</var>, <emu-val>false</emu-val>).</p>
</ol>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-4">class string</a> of an <a data-link-type="dfn" href="#dfn-iterator-prototype-object" id="ref-for-dfn-iterator-prototype-object-6">iterator prototype object</a> for a given <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-125">interface</a> is the result of concatenting the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-80">identifier</a> of the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-126">interface</a> and
the string “Iterator”.</p>
<h4 class="heading settled" data-level="3.6.10" id="es-maplike"><span class="secno">3.6.10. </span><span class="content">Maplike declarations</span><a class="self-link" href="#es-maplike"></a></h4>
<p>Any object that implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-127">interface</a> that has a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-16">maplike declaration</a> must have a [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, which is
initially set to a newly created <emu-val>Map</emu-val> object.
This <emu-val>Map</emu-val> object’s [[MapData]] internal slot is
the object’s <a data-link-type="dfn" href="#dfn-map-entries" id="ref-for-dfn-map-entries-3">map entries</a>.</p>
<p>If an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-128">interface</a> <var>A</var> is declared with
a <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-17">maplike declaration</a>, then
there exists a number of additional properties on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-38">interface prototype object</a>.
These additional properties are described in the sub-sections below.</p>
<p>Some of the properties below are defined to have a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-13">function object</a> value
that <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-forwards-to-the-internal-map-object">forwards to the internal map object</dfn> for a given function name. Such functions behave as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>Let <var>arguments</var> be the list of arguments passed to this function.</p>
<li data-md="">
<p>Let <var>name</var> be the function name.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-39">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-12">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>an identifier equal to <var>name</var>, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-60">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>map</var> be the <emu-val>Map</emu-val> object that is the value of <var>O</var>’s [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>map</var> passing <var>name</var> and <var>map</var> as arguments.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>function</var>) is <emu-val>false</emu-val>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-61">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the result of calling the [[Call]] internal method of <var>function</var> with <var>map</var> as <var>thisArg</var> and <var>arguments</var> as <var>argumentsList</var>.</p>
</ol>
<h5 class="heading settled" data-level="3.6.10.1" id="es-map-size"><span class="secno">3.6.10.1. </span><span class="content">size</span><a class="self-link" href="#es-map-size"></a></h5>
<p>There must exist a property named “size” on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-39">interface prototype object</a> with the following characteristics:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Get]]: <var>G</var>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>,
where <var>G</var> is the interface’s <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-map-size-getter">map size getter</dfn>,
defined below.</p>
<li data-md="">
<p>The <a data-link-type="dfn" href="#dfn-map-size-getter" id="ref-for-dfn-map-size-getter-2">map size getter</a> is
a <emu-val>Function</emu-val> object whose
behavior when invoked is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-40">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-13">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “size”, and</p>
<li data-md="">
<p>the type “getter”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-62">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>map</var> be the <emu-val>Map</emu-val> object that is the value of <var>O</var>’s [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Return the result of calling the [[Get]] internal method of <var>map</var> passing “size” and <var>map</var> as arguments.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “size”.</p>
</ul>
<h5 class="heading settled" data-level="3.6.10.2" id="es-map-entries"><span class="secno">3.6.10.2. </span><span class="content">entries</span><a class="self-link" href="#es-map-entries"></a></h5>
<p>A property named “entries” must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-40">interface prototype object</a> with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is the <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-14">function object</a> that is the value of
the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> property.</p>
<h5 class="heading settled" data-level="3.6.10.3" id="es-map-keys-values"><span class="secno">3.6.10.3. </span><span class="content">keys and values</span><a class="self-link" href="#es-map-keys-values"></a></h5>
<p>For both of “keys” and “values”, there must exist a property with that name on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-41">interface prototype object</a> with the following characteristics:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that <a data-link-type="dfn" href="#dfn-forwards-to-the-internal-map-object" id="ref-for-dfn-forwards-to-the-internal-map-object-1">forwards that name to the internal map object</a>.</p>
</ul>
<p>The value of the <emu-val>Function</emu-val> objects’ “length” properties is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “keys” or “values”, correspondingly.</p>
<h5 class="heading settled" data-level="3.6.10.4" id="es-map-get-has"><span class="secno">3.6.10.4. </span><span class="content">get and has</span><a class="self-link" href="#es-map-get-has"></a></h5>
<p>For both of “get” and “has”, there must exist a property with that name on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-42">interface prototype object</a> with the following characteristics:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that behaves as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>Let <var>name</var> be the name of the property – “get” or “has”.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-41">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-14">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>an identifier equal to <var>name</var>, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-63">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>map</var> be the <emu-val>Map</emu-val> object that is the value of <var>O</var>’s [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>keyType</var> be the key type specified in the <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-18">maplike declaration</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>map</var> passing <var>name</var> and <var>map</var> as arguments.</p>
<li data-md="">
<p>Let <var>keyArg</var> be the first argument passed to this function, or <emu-val>undefined</emu-val> if not supplied.</p>
<li data-md="">
<p>Let <var>keyIDL</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-62">converting</a> <var>keyArg</var> to an IDL value of type <var>keyType</var>.</p>
<li data-md="">
<p>Let <var>key</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-51">converting</a> <var>keyIDL</var> to an ECMAScript value.</p>
<li data-md="">
<p>Return the result of calling the [[Call]] internal method of <var>function</var> with <var>map</var> as <var>thisArg</var> and the single value <var>key</var> as <var>argumentsList</var>.</p>
</ol>
</ul>
<p>The value of the <emu-val>Function</emu-val> objects’ “length” properties is the <emu-val>Number</emu-val> value <emu-val>1</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “get” or “has”, correspondingly.</p>
<h5 class="heading settled" data-level="3.6.10.5" id="es-map-clear"><span class="secno">3.6.10.5. </span><span class="content">clear</span><a class="self-link" href="#es-map-clear"></a></h5>
<p>If <var>A</var> and <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-32">consequential interfaces</a> do not declare an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-21">interface member</a> with identifier “clear”, and <var>A</var> was declared with a read–write maplike declaration,
then a property named “clear” and the following characteristics
must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-43">interface prototype object</a>:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that <a data-link-type="dfn" href="#dfn-forwards-to-the-internal-map-object" id="ref-for-dfn-forwards-to-the-internal-map-object-2">forwards “clear” to the internal map object</a>.</p>
</ul>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “clear”.</p>
<h5 class="heading settled" data-level="3.6.10.6" id="es-map-delete"><span class="secno">3.6.10.6. </span><span class="content">delete</span><a class="self-link" href="#es-map-delete"></a></h5>
<p>If <var>A</var> and <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-33">consequential interfaces</a> do not declare an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-22">interface member</a> with identifier “delete”, and <var>A</var> was declared with a read–write maplike declaration,
then a property named “delete” and the following characteristics
must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-44">interface prototype object</a>:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that behaves as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-42">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-15">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “delete”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-64">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>map</var> be the <emu-val>Map</emu-val> object that is the value of <var>O</var>’s [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>keyType</var> be the key type specified in the <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-19">maplike declaration</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>map</var> passing “delete” and <var>map</var> as arguments.</p>
<li data-md="">
<p>Let <var>keyArg</var> be the first argument passed to this function, or <emu-val>undefined</emu-val> if not supplied.</p>
<li data-md="">
<p>Let <var>keyIDL</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-63">converting</a> <var>keyArg</var> to an IDL value of type <var>keyType</var>.</p>
<li data-md="">
<p>Let <var>key</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-52">converting</a> <var>keyIDL</var> to an ECMAScript value.</p>
<li data-md="">
<p>Return the result of calling the [[Call]] internal method of <var>function</var> with <var>map</var> as <var>thisArg</var> and the single value <var>key</var> as <var>argumentsList</var>.</p>
</ol>
</ul>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>1</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “delete”.</p>
<h5 class="heading settled" data-level="3.6.10.7" id="es-map-set"><span class="secno">3.6.10.7. </span><span class="content">set</span><a class="self-link" href="#es-map-set"></a></h5>
<p>If <var>A</var> and <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-34">consequential interfaces</a> do not declare an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-23">interface member</a> with identifier “set”, and <var>A</var> was declared with a read–write maplike declaration,
then a property named “set” and the following characteristics
must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-45">interface prototype object</a>:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that behaves as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-43">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-16">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “set”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-65">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>map</var> be the <emu-val>Map</emu-val> object that is the value of <var>O</var>’s [[BackingMap]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>keyType</var> and <var>valueType</var> be the key and value types specified in the <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-20">maplike declaration</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>map</var> passing “set” and <var>map</var> as arguments.</p>
<li data-md="">
<p>Let <var>keyArg</var> be the first argument passed to this function, or <emu-val>undefined</emu-val> if not supplied.</p>
<li data-md="">
<p>Let <var>valueArg</var> be the second argument passed to this function, or <emu-val>undefined</emu-val> if not supplied.</p>
<li data-md="">
<p>Let <var>keyIDL</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-64">converting</a> <var>keyArg</var> to an IDL value of type <var>keyType</var>.</p>
<li data-md="">
<p>Let <var>valueIDL</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-65">converting</a> <var>valueArg</var> to an IDL value of type <var>valueType</var>.</p>
<li data-md="">
<p>Let <var>key</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-53">converting</a> <var>keyIDL</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-54">converting</a> <var>valueIDL</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>result</var> be the result of calling the [[Call]] internal method of <var>function</var> with <var>map</var> as <var>thisArg</var> and <var>key</var> and <var>value</var> as <var>argumentsList</var>.</p>
<li data-md="">
<p class="assertion">Assert: <var>result</var> is not an abrupt completion.</p>
<li data-md="">
<p>Return <var>O</var>.</p>
</ol>
</ul>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>2</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “set”.</p>
<h4 class="heading settled" data-level="3.6.11" id="es-setlike"><span class="secno">3.6.11. </span><span class="content">Setlike declarations</span><a class="self-link" href="#es-setlike"></a></h4>
<p>Any object that implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-129">interface</a> that has a <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-14">setlike declaration</a> must have a [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>, which is
initially set to a newly created <emu-val>Set</emu-val> object.
This <emu-val>Set</emu-val> object’s [[SetData]] internal slot is
the object’s <a data-link-type="dfn" href="#dfn-set-entries" id="ref-for-dfn-set-entries-3">set entries</a>.</p>
<p>If an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-130">interface</a> <var>A</var> is declared with
a <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-15">setlike declaration</a>, then
there exists a number of additional properties on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-46">interface prototype object</a>.
These additional properties are described in the sub-sections below.</p>
<p>Some of the properties below are defined to have a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-15">function object</a> value
that <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-forwards-to-the-internal-set-object">forwards to the internal set object</dfn> for a given function name. Such functions behave as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>Let <var>arguments</var> be the list of arguments passed to this function.</p>
<li data-md="">
<p>Let <var>name</var> be the function name.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-44">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-17">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>an identifier equal to <var>name</var>, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-66">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>set</var> be the <emu-val>Set</emu-val> object that is the value of <var>O</var>’s [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>set</var> passing <var>name</var> and <var>set</var> as arguments.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>function</var>) is <emu-val>false</emu-val>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-67">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Return the result of calling the [[Call]] internal method of <var>function</var> with <var>set</var> as <var>thisArg</var> and <var>arguments</var> as <var>argumentsList</var>.</p>
</ol>
<h5 class="heading settled" data-level="3.6.11.1" id="es-set-size"><span class="secno">3.6.11.1. </span><span class="content">size</span><a class="self-link" href="#es-set-size"></a></h5>
<p>There must exist a property named “size” on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-47">interface prototype object</a> with the following characteristics:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Get]]: <var>G</var>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>,
where <var>G</var> is the interface’s <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-set-size-getter">set size getter</dfn>,
defined below.</p>
<li data-md="">
<p>The <a data-link-type="dfn" href="#dfn-set-size-getter" id="ref-for-dfn-set-size-getter-1">set size getter</a> is
a <emu-val>Function</emu-val> object whose
behavior when invoked is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-45">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-18">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “size”, and</p>
<li data-md="">
<p>the type “getter”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-68">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>set</var> be the <emu-val>Set</emu-val> object that is the value of <var>O</var>’s [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Return the result of calling the [[Get]] internal method of <var>set</var> passing “size” and <var>set</var> as arguments.</p>
</ol>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “size”.</p>
</ul>
<h5 class="heading settled" data-level="3.6.11.2" id="es-set-values"><span class="secno">3.6.11.2. </span><span class="content">values</span><a class="self-link" href="#es-set-values"></a></h5>
<p>A property named “values” must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-48">interface prototype object</a> with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is the <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-16">function object</a> that is the value of
the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a> property.</p>
<h5 class="heading settled" data-level="3.6.11.3" id="es-set-entries-keys"><span class="secno">3.6.11.3. </span><span class="content">entries and keys</span><a class="self-link" href="#es-set-entries-keys"></a></h5>
<p>For both of “entries” and “keys”, there must exist a property with that name on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-49">interface prototype object</a> with the following characteristics:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that <a data-link-type="dfn" href="#dfn-forwards-to-the-internal-set-object" id="ref-for-dfn-forwards-to-the-internal-set-object-1">forwards that name to the internal set object</a>.</p>
</ul>
<p>The value of the <emu-val>Function</emu-val> objects’ “length” properties is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “entries” or “keys”, correspondingly.</p>
<h5 class="heading settled" data-level="3.6.11.4" id="es-set-has"><span class="secno">3.6.11.4. </span><span class="content">has</span><a class="self-link" href="#es-set-has"></a></h5>
<p>There must exist a property with named “has” on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-50">interface prototype object</a> with the following characteristics:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that behaves as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-46">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-19">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>the identifier “has”, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-69">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>set</var> be the <emu-val>Set</emu-val> object that is the value of <var>O</var>’s [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>type</var> be the value type specified in the <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-16">setlike declaration</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>set</var> passing “has” and <var>set</var> as arguments.</p>
<li data-md="">
<p>Let <var>arg</var> be the first argument passed to this function, or <emu-val>undefined</emu-val> if not supplied.</p>
<li data-md="">
<p>Let <var>idlValue</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-66">converting</a> <var>arg</var> to an IDL value of type <var>type</var>.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-55">converting</a> <var>idlValue</var> to an ECMAScript value.</p>
<li data-md="">
<p>Return the result of calling the [[Call]] internal method of <var>function</var> with <var>set</var> as <var>thisArg</var> and the single value <var>value</var> as <var>argumentsList</var>.</p>
</ol>
</ul>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is a <emu-val>Number</emu-val> value <emu-val>1</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “has”.</p>
<h5 class="heading settled" data-level="3.6.11.5" id="es-add-delete"><span class="secno">3.6.11.5. </span><span class="content">add and delete</span><a class="self-link" href="#es-add-delete"></a></h5>
<p>For both of “add” and “delete”, if:</p>
<ul>
<li data-md="">
<p><var>A</var> and <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-35">consequential interfaces</a> do not declare an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-24">interface member</a> with a matching identifier, and</p>
<li data-md="">
<p><var>A</var> was declared with a read–write setlike declaration,</p>
</ul>
<p>then a property with that name and the following characteristics
must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-51">interface prototype object</a>:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that behaves as follows when invoked:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the <emu-val>this</emu-val> value.</p>
<li data-md="">
<p>Let <var>name</var> be the name of the property – “add” or “delete”.</p>
<li data-md="">
<p>If <var>O</var> is a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-47">platform object</a>,
then <a data-link-type="dfn" href="#dfn-perform-a-security-check" id="ref-for-dfn-perform-a-security-check-20">perform a security check</a>, passing:</p>
<ul>
<li data-md="">
<p>the platform object <var>O</var>,</p>
<li data-md="">
<p>the ECMAScript global environment associated with this <emu-val>Function</emu-val>,</p>
<li data-md="">
<p>an identifier equal to <var>name</var>, and</p>
<li data-md="">
<p>the type “method”.</p>
</ul>
<li data-md="">
<p>If <var>O</var> is not an object that implements <var>A</var>, then <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-70">throw a <emu-val>TypeError</emu-val></a>.</p>
<li data-md="">
<p>Let <var>set</var> be the <emu-val>Set</emu-val> object that is the value of <var>O</var>’s [[BackingSet]] <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>.</p>
<li data-md="">
<p>Let <var>type</var> be the value type specified in the <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-17">setlike declaration</a>.</p>
<li data-md="">
<p>Let <var>function</var> be the result of calling the [[Get]] internal method of <var>set</var> passing <var>name</var> and <var>set</var> as arguments.</p>
<li data-md="">
<p>Let <var>arg</var> be the first argument passed to this function, or <emu-val>undefined</emu-val> if not supplied.</p>
<li data-md="">
<p>Let <var>idlValue</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-67">converting</a> <var>arg</var> to an IDL value of type <var>type</var>.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-56">converting</a> <var>idlValue</var> to an ECMAScript value.</p>
<li data-md="">
<p>Let <var>result</var> be the result of calling the [[Call]] internal method of <var>function</var> with <var>set</var> as <var>thisArg</var> and the single value <var>value</var> as <var>argumentsList</var>.</p>
<li data-md="">
<p class="assertion">Assert: <var>result</var> is not an abrupt completion.</p>
<li data-md="">
<p>If <var>name</var> is "delete", then:</p>
<ol>
<li data-md="">
<p>Return <var>result</var>.</p>
</ol>
<li data-md="">
<p>Otherwise:</p>
<ol>
<li data-md="">
<p>Return <var>O</var>.</p>
</ol>
</ol>
</ul>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>1</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “add” or “delete”, correspondingly.</p>
<h5 class="heading settled" data-level="3.6.11.6" id="es-set-clear"><span class="secno">3.6.11.6. </span><span class="content">clear</span><a class="self-link" href="#es-set-clear"></a></h5>
<p>If <var>A</var> and <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-36">consequential interfaces</a> do not declare an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-25">interface member</a> with a matching identifier, and <var>A</var> was declared with a read–write setlike declaration,
then a property named “clear” and the following characteristics
must exist on <var>A</var>’s <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-52">interface prototype object</a>:</p>
<ul>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object that <a data-link-type="dfn" href="#dfn-forwards-to-the-internal-set-object" id="ref-for-dfn-forwards-to-the-internal-set-object-2">forwards “clear” to the internal set object</a>.</p>
</ul>
<p>The value of the <emu-val>Function</emu-val> object’s “length” property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “clear”.</p>
<h3 class="heading settled" data-level="3.7" id="es-implements-statements"><span class="secno">3.7. </span><span class="content">Implements statements</span><a class="self-link" href="#es-implements-statements"></a></h3>
<p>The <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-53">interface prototype object</a> of an interface <var>A</var> must have a copy of
each property that corresponds to one of the <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-28">constants</a>, <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-75">attributes</a>, <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-74">operations</a>, <a data-link-type="dfn" href="#dfn-iterable-declaration" id="ref-for-dfn-iterable-declaration-18">iterable declarations</a>, <a data-link-type="dfn" href="#dfn-maplike-declaration" id="ref-for-dfn-maplike-declaration-21">maplike declarations</a> and <a data-link-type="dfn" href="#dfn-setlike-declaration" id="ref-for-dfn-setlike-declaration-18">setlike declarations</a> that exist on all of the interface prototype objects of <var>A</var>’s <a data-link-type="dfn" href="#dfn-consequential-interfaces" id="ref-for-dfn-consequential-interfaces-37">consequential interfaces</a>.
For operations, where the property is a data property with a <emu-val>Function</emu-val> object value, each copy of the property must have
distinct <emu-val>Function</emu-val> objects. For attributes, each
copy of the accessor property must have
distinct <emu-val>Function</emu-val> objects for their getters,
and similarly with their setters.</p>
<div class="note" role="note">
<p>When invoking an <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-75">operation</a> by calling
a <emu-val>Function</emu-val> object that is the value of one of the copies that exists
due to an implements statement, the <emu-val>this</emu-val> value is
checked to ensure that it is an object that implements the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-131">interface</a> corresponding to the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-54">interface prototype object</a> that the property is on.</p>
<p>For example, consider the following IDL:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
<span class="kt">void</span> <span class="nv">f</span>();
};
<span class="kt">interface</span> <span class="nv">B</span> { };
<span class="n">B</span> <span class="kt">implements</span> <span class="n">A</span>;
<span class="kt">interface</span> <span class="nv">C</span> { };
<span class="n">C</span> <span class="kt">implements</span> <span class="n">A</span>;
</pre>
<p>Attempting to call <code>B.prototype.f</code> on an object that implements <code class="idl">A</code> (but not <code class="idl">B</code>) or one
that implements <code class="idl">C</code> will result in a <code class="idl"><a data-link-type="idl" href="#exceptiondef-typeerror" id="ref-for-exceptiondef-typeerror-3">TypeError</a></code> being thrown. However,
calling <code>A.prototype.f</code> on an object that implements <code class="idl">B</code> or one that implements <code class="idl">C</code> would succeed. This is handled by the algorithm in <a href="#es-operations">§3.6.7 Operations</a> that defines how IDL operation invocation works in ECMAScript.</p>
<p>Similar behavior is required for the getter and setter <emu-val>Function</emu-val> objects that correspond to an IDL <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-76">attributes</a>,
and this is handled in <a href="#es-attributes">§3.6.6 Attributes</a>.</p>
</div>
<h3 class="heading settled" data-level="3.8" id="es-platform-objects"><span class="secno">3.8. </span><span class="content">Platform objects implementing interfaces</span><a class="self-link" href="#es-platform-objects"></a></h3>
<p>Every <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-48">platform object</a> is associated with a global environment, just
as the <a data-link-type="dfn" href="#dfn-initial-object" id="ref-for-dfn-initial-object-4">initial objects</a> are.
It is the responsibility of specifications using Web IDL to state
which global environment (or, by proxy, which global object) each platform
object is associated with.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-primary-interface">primary interface</dfn> of a platform object
that implements one or more interfaces is the most-derived <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-7">non-supplemental interface</a> that it implements. The value of the internal [[Prototype]]
property of the platform object is the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-55">interface prototype object</a> of the <a data-link-type="dfn" href="#dfn-primary-interface" id="ref-for-dfn-primary-interface-1">primary interface</a> from the <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-49">platform object</a>’s associated global environment.</p>
<p>The global environment that a given <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-50">platform object</a> is associated with can <dfn data-dfn-for="global environment" data-dfn-type="dfn" data-export="" id="dfn-change-global-environment">change<a class="self-link" href="#dfn-change-global-environment"></a></dfn> after it has been created. When
the global environment associated with a platform object is changed, its internal
[[Prototype]] property must be immediately
updated to be the <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-56">interface prototype object</a> of the <a data-link-type="dfn" href="#dfn-primary-interface" id="ref-for-dfn-primary-interface-2">primary interface</a> from the <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-51">platform object</a>’s newly associated global environment.</p>
<p>Every platform object that implements an [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-15">Unforgeable</a></code>]-annotated
interface and which does not have a <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-7">stringifier</a> that is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-7">unforgeable</a> on any of the
interfaces it implements must have a property with the
following characteristics:</p>
<ul>
<li data-md="">
<p>The name of the property is “toString”.</p>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ObjProto_toString%</a>, the initial value of Object.prototype.toString.</p>
</ul>
<p>Every platform object that implements an [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-16">Unforgeable</a></code>]-annotated
interface and which does not have a <a data-link-type="dfn" href="#dfn-serializer" id="ref-for-dfn-serializer-8">serializer</a> that is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-8">unforgeable</a> on any of the
interfaces it implements must have a property with the
following characteristics:</p>
<ul>
<li data-md="">
<p>The name of the property is “toJSON”.</p>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is <emu-val>undefined</emu-val>.</p>
</ul>
<p>Every platform object that implements an [<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-17">Unforgeable</a></code>]-annotated
interface must have a property with the
following characteristics:</p>
<ul>
<li data-md="">
<p>The name of the property is “valueOf”.</p>
<li data-md="">
<p>The property has attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span>.</p>
<li data-md="">
<p>The value of the property is a <emu-val>Function</emu-val> object whose behavior
is as follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Return the <emu-val>this</emu-val> value.</p>
</ol>
<p>This <emu-val>Function</emu-val> object is the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-default-unforgeable-valueOf-function">default unforgeable valueOf function</dfn>.</p>
<li data-md="">
<p>The value of the <emu-val>Function</emu-val> object’s “length”
property is the <emu-val>Number</emu-val> value <emu-val>0</emu-val>.</p>
<li data-md="">
<p>The value of the <emu-val>Function</emu-val> object’s “name” property is the <emu-val>String</emu-val> value “valueOf”.</p>
</ul>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-5">class string</a> of
a platform object that implements one or more interfaces
must be the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-81">identifier</a> of
the <a data-link-type="dfn" href="#dfn-primary-interface" id="ref-for-dfn-primary-interface-3">primary interface</a> of the platform object.</p>
<h4 class="heading settled" data-level="3.8.1" id="indexed-and-named-properties"><span class="secno">3.8.1. </span><span class="content">Indexed and named properties</span><a class="self-link" href="#indexed-and-named-properties"></a></h4>
<p>If a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-52">platform object</a> implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-132">interface</a> that <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-9">supports indexed</a> or <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-5">named properties</a>,
the object will appear to have additional properties that correspond to the
object’s indexed and named properties. These properties are not “real” own
properties on the object, but are made to look like they are by being exposed
by the [[GetOwnProperty]] internal method.</p>
<p>However, when the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-93">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-94">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-99">extended attribute</a> has been used,
named properties are not exposed on the object but on another object
in the prototype chain, the <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-13">named properties object</a>.</p>
<p>It is permissible for an object to implement multiple interfaces that support indexed properties.
However, if so, and there are conflicting definitions as to the object’s <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-4">supported property indices</a>,
or if one of the interfaces is a <a data-link-type="dfn" href="#dfn-supplemental-interface" id="ref-for-dfn-supplemental-interface-8">supplemental interface</a> for the
platform object, then it is undefined what additional properties the object will appear to
have, or what its exact behavior will be with regard to its indexed properties.
The same applies for named properties.</p>
<p>The <a data-link-type="dfn" href="#dfn-indexed-property-getter" id="ref-for-dfn-indexed-property-getter-8">indexed property getter</a> that is defined on the derived-most interface that the
platform object implements is the one that defines the behavior
when indexing the object with an array index. Similarly for <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-4">indexed property setters</a>.
This way, the definitions of these special operations from
ancestor interfaces can be overridden.</p>
<p>Platform objects implementing an interface that supports indexed or named properties cannot be fixed; if <code>Object.freeze</code>, <code>Object.seal</code> or <code>Object.preventExtensions</code> is called on one of these objects, the function
must <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-71">throw a <emu-val>TypeError</emu-val></a>.
Similarly, an <a data-link-type="dfn" href="#dfn-interface-prototype-object" id="ref-for-dfn-interface-prototype-object-57">interface prototype object</a> that exposes named properties due to the use of [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-95">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-96">PrimaryGlobal</a></code>]
also must <a data-link-type="dfn" href="#ecmascript-throw" id="ref-for-ecmascript-throw-72">throw a <emu-val>TypeError</emu-val></a> if one of the three functions above is called on it.</p>
<p>The name of each property that appears to exist due to an object supporting indexed properties
is an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-array-index-property-name">array index property name</dfn>, which is a property
name <var>P</var> such that <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>P</var>) is String
and for which the following algorithm returns <emu-val>true</emu-val>:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>i</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>(<var>P</var>).</p>
<li data-md="">
<p>Let <var>s</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>i</var>).</p>
<li data-md="">
<p>If <var>s</var> ≠ <var>P</var> or <var>i</var> = 2<sup>32</sup> − 1, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
<p>A property name is an <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-unforgeable-property-name">unforgeable property name</dfn> on a
given platform object if the object implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-133">interface</a> that
has an <a data-link-type="dfn" href="#dfn-interface-member" id="ref-for-dfn-interface-member-26">interface member</a> with that identifier
and that interface member is <a data-link-type="dfn" href="#dfn-unforgeable-on-an-interface" id="ref-for-dfn-unforgeable-on-an-interface-9">unforgeable</a> on any of
the interfaces that <var>O</var> implements. If the object implements an
[<code class="idl"><a data-link-type="idl" href="#Unforgeable" id="ref-for-Unforgeable-18">Unforgeable</a></code>]-annotated <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-134">interface</a>, then “toString” and “valueOf” are
also <a data-link-type="dfn" href="#dfn-unforgeable-property-name" id="ref-for-dfn-unforgeable-property-name-1">unforgeable property names</a> on that object.</p>
<p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-named-property-visibility">named property visibility algorithm</dfn> is used to determine if
a given named property is exposed on an object. Some named properties are not exposed on an object
depending on whether the [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-8">OverrideBuiltins</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-100">extended attribute</a> was used. The algorithm
operates as follows, with property name <var>P</var> and object <var>O</var>:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>P</var> is not a <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-4">supported property name</a> of <var>O</var>, then return false.</p>
<li data-md="">
<p>If <var>O</var> has an own property named <var>P</var>, then return false.</p>
<p class="note" role="note">Note: This will include cases in which <var>O</var> has unforgeable properties, because in practice those are always set up before objects have any supported property names, and once set up will make the corresponding named properties invisible.</p>
<li data-md="">
<p>If <var>O</var> implements an interface that has the [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-9">OverrideBuiltins</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-101">extended attribute</a>, then return true.</p>
<li data-md="">
<p>Initialize <var>prototype</var> to be the value of the internal [[Prototype]] property of <var>O</var>.</p>
<li data-md="">
<p>While <var>prototype</var> is not null:</p>
<ol>
<li data-md="">
<p>If <var>prototype</var> is not a <a data-link-type="dfn" href="#dfn-named-properties-object" id="ref-for-dfn-named-properties-object-14">named properties object</a>,
and <var>prototype</var> has an own property named <var>P</var>, then return false.</p>
<li data-md="">
<p>Set <var>prototype</var> to be the value of the internal [[Prototype]] property of <var>prototype</var>.</p>
</ol>
<li data-md="">
<p>Return true.</p>
</ol>
<div class="note" role="note">
<p>This should ensure that for objects with named properties, property resolution is done in the following order:</p>
<ol>
<li data-md="">
<p>Indexed properties.</p>
<li data-md="">
<p>Own properties, including unforgeable attributes and operations.</p>
<li data-md="">
<p>Then, if [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-10">OverrideBuiltins</a></code>]:</p>
<ol>
<li data-md="">
<p>Named properties.</p>
<li data-md="">
<p>Properties from the prototype chain.</p>
</ol>
<li data-md="">
<p>Otherwise, if not [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-11">OverrideBuiltins</a></code>]:</p>
<ol>
<li data-md="">
<p>Properties from the prototype chain.</p>
<li data-md="">
<p>Named properties.</p>
</ol>
</ol>
</div>
<p>Support for <a data-link-type="dfn" href="#dfn-getter" id="ref-for-dfn-getter-1">getters</a> is
handled by the <a href="#getownproperty">platform object [[GetOwnProperty]] method</a> defined in section <a href="#getownproperty">§3.8.3 Platform object [[GetOwnProperty]] method</a>, and
for <a data-link-type="dfn" href="#dfn-setter" id="ref-for-dfn-setter-1">setters</a> by the <a href="#defineownproperty">platform object [[DefineOwnProperty]] method</a> defined in section <a href="#defineownproperty">§3.8.7 Platform object [[DefineOwnProperty]] method</a> and the <a href="#platformobjectset">platform object [[Set]] method</a> defined in section <a href="#platformobjectset">§3.8.6 Platform object [[Set]] method</a>.</p>
<h4 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="3.8.2" data-lt="The PlatformObjectGetOwnProperty abstract operation" data-noexport="" id="getownproperty-guts"><span class="secno">3.8.2. </span><span class="content">The PlatformObjectGetOwnProperty abstract operation</span></h4>
<p>The PlatformObjectGetOwnProperty
abstract operation performs the following steps when called with an
object <var>O</var>, a property name <var>P</var>, and a boolean <var>ignoreNamedProps</var> value:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-10">supports indexed properties</a> and <var>P</var> is an <a data-link-type="dfn" href="#dfn-array-index-property-name" id="ref-for-dfn-array-index-property-name-1">array index property name</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>index</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>(<var>P</var>).</p>
<li data-md="">
<p>If <var>index</var> is a <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-5">supported property index</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>operation</var> be the operation used to declare the indexed property getter.</p>
<li data-md="">
<p>Let <var>value</var> be an uninitialized variable.</p>
<li data-md="">
<p>If <var>operation</var> was defined without an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-82">identifier</a>, then
set <var>value</var> to the result of performing the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-determine-the-value-of-an-indexed-property" id="ref-for-dfn-determine-the-value-of-an-indexed-property-1">determine the value of an indexed property</a> with <var>index</var> as the index.</p>
<li data-md="">
<p>Otherwise, <var>operation</var> was defined with an identifier. Set <var>value</var> to the result
of performing the steps listed in the description of <var>operation</var> with <var>index</var> as the only argument value.</p>
<li data-md="">
<p>Let <var>desc</var> be a newly created <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-property-descriptor-specification-type">Property Descriptor</a> with no fields.</p>
<li data-md="">
<p>Set <var>desc</var>.[[Value]] to the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-57">converting</a> <var>value</var> to an ECMAScript value.</p>
<li data-md="">
<p>If <var>O</var> implements an interface with an <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-5">indexed property setter</a>, then set <var>desc</var>.[[Writable]] to <emu-val>true</emu-val>, otherwise set it to <emu-val>false</emu-val>.</p>
<li data-md="">
<p>Set <var>desc</var>.[[Enumerable]] and <var>desc</var>.[[Configurable]] to <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Return <var>desc</var>.</p>
</ol>
<li data-md="">
<p>Set <var>ignoreNamedProps</var> to true.</p>
</ol>
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-6">supports named properties</a>, <var>O</var> does not
implement an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-135">interface</a> with the [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-97">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-98">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-102">extended attribute</a>, the result of running the <a data-link-type="dfn" href="#dfn-named-property-visibility" id="ref-for-dfn-named-property-visibility-2">named property visibility algorithm</a> with
property name <var>P</var> and object <var>O</var> is true, and <var>ignoreNamedProps</var> is false, then:</p>
<ol>
<li data-md="">
<p>Let <var>operation</var> be the operation used to declare the named property getter.</p>
<li data-md="">
<p>Let <var>value</var> be an uninitialized variable.</p>
<li data-md="">
<p>If <var>operation</var> was defined without an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-83">identifier</a>, then
set <var>value</var> to the result of performing the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-determine-the-value-of-a-named-property" id="ref-for-dfn-determine-the-value-of-a-named-property-2">determine the value of a named property</a> with <var>P</var> as the name.</p>
<li data-md="">
<p>Otherwise, <var>operation</var> was defined with an identifier. Set <var>value</var> to the result
of performing the steps listed in the description of <var>operation</var> with <var>P</var> as the only argument value.</p>
<li data-md="">
<p>Let <var>desc</var> be a newly created <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-property-descriptor-specification-type">Property Descriptor</a> with no fields.</p>
<li data-md="">
<p>Set <var>desc</var>.[[Value]] to the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-58">converting</a> <var>value</var> to an ECMAScript value.</p>
<li data-md="">
<p>If <var>O</var> implements an interface with a <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-4">named property setter</a>, then set <var>desc</var>.[[Writable]] to <emu-val>true</emu-val>, otherwise set it to <emu-val>false</emu-val>.</p>
<li data-md="">
<p>If <var>O</var> implements an interface with the
[<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-6">LegacyUnenumerableNamedProperties</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-103">extended attribute</a>,
then set <var>desc</var>.[[Enumerable]] to <emu-val>false</emu-val>,
otherwise set it to <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Set <var>desc</var>.[[Configurable]] to <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Return <var>desc</var>.</p>
</ol>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ordinarygetownproperty">OrdinaryGetOwnProperty</a>(<var>O</var>, <var>P</var>).</p>
</ol>
<h4 class="heading settled" data-level="3.8.3" id="getownproperty"><span class="secno">3.8.3. </span><span class="content">Platform object [[GetOwnProperty]] method</span><a class="self-link" href="#getownproperty"></a></h4>
<p>The internal [[GetOwnProperty]] method of every <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-53">platform object</a> <var>O</var> that implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-136">interface</a> which <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-11">supports indexed</a> or <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-7">named properties</a> must behave as follows when called with property name <var>P</var>:</p>
<ol class="algorithm">
<li data-md="">
<p>Return the result of invoking the <a data-link-type="dfn" href="#getownproperty-guts" id="ref-for-getownproperty-guts-1">PlatformObjectGetOwnProperty</a> abstract operation with <var>O</var>, <var>P</var>, and <emu-val>false</emu-val> as
arguments.</p>
</ol>
<h4 class="heading settled" data-level="3.8.4" id="invoking-indexed-setter"><span class="secno">3.8.4. </span><span class="content">Invoking a platform object indexed property setter</span><a class="self-link" href="#invoking-indexed-setter"></a></h4>
<p>To <dfn data-dfn-type="dfn" data-export="" data-lt="invoke the indexed property setter" id="invoke-indexed-setter">invoke an indexed property setter<a class="self-link" href="#invoke-indexed-setter"></a></dfn> with property name <var>P</var> and ECMAScript value <var>V</var>, the following steps must be performed:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>index</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>(<var>P</var>).</p>
<li data-md="">
<p>Let <var>creating</var> be true if <var>index</var> is not a <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-6">supported property index</a>, and false otherwise.</p>
<li data-md="">
<p>Let <var>operation</var> be the operation used to declare the indexed property setter.</p>
<li data-md="">
<p>Let <var>T</var> be the type of the second argument of <var>operation</var>.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-68">converting</a> <var>V</var> to an IDL value of type <var>T</var>.</p>
<li data-md="">
<p>If <var>operation</var> was defined without an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-84">identifier</a>, then:</p>
<ol>
<li data-md="">
<p>If <var>creating</var> is true, then perform the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-set-the-value-of-a-new-indexed-property" id="ref-for-dfn-set-the-value-of-a-new-indexed-property-1">set the value of a new indexed property</a> with <var>index</var> as the index and <var>value</var> as the value.</p>
<li data-md="">
<p>Otherwise, <var>creating</var> is false. Perform the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-set-the-value-of-an-existing-indexed-property" id="ref-for-dfn-set-the-value-of-an-existing-indexed-property-1">set the value of an existing indexed property</a> with <var>index</var> as the index and <var>value</var> as the value.</p>
</ol>
<li data-md="">
<p>Otherwise, <var>operation</var> was defined with an identifier. Perform the steps listed in the description of <var>operation</var> with <var>index</var> and <var>value</var> as the two argument values.</p>
</ol>
<h4 class="heading settled" data-level="3.8.5" id="invoking-named-setter"><span class="secno">3.8.5. </span><span class="content">Invoking a platform object named property setter</span><a class="self-link" href="#invoking-named-setter"></a></h4>
<p>To <dfn data-dfn-type="dfn" data-export="" data-lt="invoke the named property setter" id="invoke-named-setter">invoke a named property setter<a class="self-link" href="#invoke-named-setter"></a></dfn> with property name <var>P</var> and ECMAScript value <var>V</var>, the following steps must be performed:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>creating</var> be true if <var>P</var> is not a <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-5">supported property name</a>, and false otherwise.</p>
<li data-md="">
<p>Let <var>operation</var> be the operation used to declare the named property setter.</p>
<li data-md="">
<p>Let <var>T</var> be the type of the second argument of <var>operation</var>.</p>
<li data-md="">
<p>Let <var>value</var> be the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-69">converting</a> <var>V</var> to an IDL value of type <var>T</var>.</p>
<li data-md="">
<p>If <var>operation</var> was defined without an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-85">identifier</a>, then:</p>
<ol>
<li data-md="">
<p>If <var>creating</var> is true, then perform the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-set-the-value-of-a-new-named-property" id="ref-for-dfn-set-the-value-of-a-new-named-property-1">set the value of a new named property</a> with <var>P</var> as the name and <var>value</var> as the value.</p>
<li data-md="">
<p>Otherwise, <var>creating</var> is false. Perform the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-set-the-value-of-an-existing-named-property" id="ref-for-dfn-set-the-value-of-an-existing-named-property-1">set the value of an existing named property</a> with <var>P</var> as the name and <var>value</var> as the value.</p>
</ol>
<li data-md="">
<p>Otherwise, <var>operation</var> was defined with an identifier. Perform the steps listed in the description of <var>operation</var> with <var>index</var> and <var>value</var> as the two argument values.</p>
</ol>
<h4 class="heading settled" data-level="3.8.6" id="platformobjectset"><span class="secno">3.8.6. </span><span class="content">Platform object [[Set]] method</span><a class="self-link" href="#platformobjectset"></a></h4>
<p>The internal [[Set]] method of every <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-54">platform object</a> <var>O</var> that implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-137">interface</a> which <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-12">supports indexed</a> or <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-8">named properties</a> must behave as follows when called
with property name <var>P</var>, value <var>V</var>, and
ECMAScript language value <var>Receiver</var>:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>O</var> and <var>Receiver</var> are the same object,
then:</p>
<ol>
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-13">supports indexed properties</a>, <var>P</var> is an <a data-link-type="dfn" href="#dfn-array-index-property-name" id="ref-for-dfn-array-index-property-name-2">array index property name</a>, and <var>O</var> implements an interface with an <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-6">indexed property setter</a>, then:</p>
<ol>
<li data-md="">
<p><a href="#invoking-indexed-setter">Invoke the indexed
property setter</a> with <var>P</var> and <var>V</var>.</p>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-9">supports named properties</a>, <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">Type</a>(<var>P</var>) is String, <var>P</var> is not an <a data-link-type="dfn" href="#dfn-array-index-property-name" id="ref-for-dfn-array-index-property-name-3">array index property name</a>, and <var>O</var> implements an interface with a <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-5">named property setter</a>, then:</p>
<ol>
<li data-md="">
<p><a href="#invoking-named-setter">Invoke the named
property setter</a> with <var>P</var> and <var>V</var>.</p>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
</ol>
<li data-md="">
<p>Let <var>ownDesc</var> be the result of invoking the <a data-link-type="dfn" href="#getownproperty-guts" id="ref-for-getownproperty-guts-2">PlatformObjectGetOwnProperty</a> abstract operation with <var>O</var>, <var>P</var>, and <emu-val>true</emu-val> as
arguments.</p>
<li data-md="">
<p>Perform steps 3-11 of the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-set-p-v-receiver">default [[Set]] internal method</a>.</p>
</ol>
<h4 class="heading settled" data-level="3.8.7" id="defineownproperty"><span class="secno">3.8.7. </span><span class="content">Platform object [[DefineOwnProperty]] method</span><a class="self-link" href="#defineownproperty"></a></h4>
<p>When the internal [[DefineOwnProperty]] method of a <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-55">platform object</a> <var>O</var> that
implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-138">interface</a> which <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-14">supports indexed</a> or <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-10">named properties</a> is
called with property key <var>P</var> and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-property-descriptor-specification-type">Property Descriptor</a> <var>Desc</var>, the following steps must be taken:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-15">supports indexed properties</a> and <var>P</var> is an <a data-link-type="dfn" href="#dfn-array-index-property-name" id="ref-for-dfn-array-index-property-name-4">array index property name</a>, then:</p>
<ol>
<li data-md="">
<p>If the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isdatadescriptor">IsDataDescriptor</a>(<var>Desc</var>) is <emu-val>false</emu-val>, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>If <var>O</var> does not implement an interface with an <a data-link-type="dfn" href="#dfn-indexed-property-setter" id="ref-for-dfn-indexed-property-setter-7">indexed property setter</a>, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p><a href="#invoking-indexed-setter">Invoke the indexed property setter</a> with <var>P</var> and <var>Desc</var>.[[Value]].</p>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-11">supports named properties</a>, <var>O</var> does not implement an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-139">interface</a> with the
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-99">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-100">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-104">extended attribute</a> and <var>P</var> is not an <a data-link-type="dfn" href="#dfn-unforgeable-property-name" id="ref-for-dfn-unforgeable-property-name-2">unforgeable property name</a> of <var>O</var>, then:</p>
<ol>
<li data-md="">
<p>Let <var>creating</var> be true if <var>P</var> is not a <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-6">supported property name</a>, and false otherwise.</p>
<li data-md="">
<p>If <var>O</var> implements an interface with the [<code class="idl"><a data-link-type="idl" href="#OverrideBuiltins" id="ref-for-OverrideBuiltins-12">OverrideBuiltins</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-105">extended attribute</a> or <var>O</var> does not have an own property
named <var>P</var>, then:</p>
<ol>
<li data-md="">
<p>If <var>creating</var> is false and <var>O</var> does not implement an
interface with a <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-6">named property setter</a>, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>If <var>O</var> implements an interface with a <a data-link-type="dfn" href="#dfn-named-property-setter" id="ref-for-dfn-named-property-setter-7">named property setter</a>, then:</p>
<ol>
<li data-md="">
<p>If the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isdatadescriptor">IsDataDescriptor</a>(<var>Desc</var>) is <emu-val>false</emu-val>, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p><a href="#invoking-named-setter">Invoke the named property setter</a> with <var>P</var> and <var>Desc</var>.[[Value]].</p>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
</ol>
</ol>
<li data-md="">
<p>If <var>O</var> does not implement an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-140">interface</a> with the
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-101">Global</a></code>] or
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-102">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-106">extended attribute</a>, then set <var>Desc</var>.[[Configurable]] to <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-ordinarydefineownproperty">OrdinaryDefineOwnProperty</a>(<var>O</var>, <var>P</var>, <var>Desc</var>).</p>
</ol>
<h4 class="heading settled" data-level="3.8.8" id="delete"><span class="secno">3.8.8. </span><span class="content">Platform object [[Delete]] method</span><a class="self-link" href="#delete"></a></h4>
<p>The internal [[Delete]] method of every <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-56">platform object</a> <var>O</var> that implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-141">interface</a> which <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-16">supports indexed</a> or <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-12">named properties</a> must behave as follows when called with property name <var>P</var>.</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-17">supports indexed properties</a> and <var>P</var> is an <a data-link-type="dfn" href="#dfn-array-index-property-name" id="ref-for-dfn-array-index-property-name-5">array index property name</a>, then:</p>
<ol>
<li data-md="">
<p>Let <var>index</var> be the result of calling <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-touint32">ToUint32</a>(<var>P</var>).</p>
<li data-md="">
<p>If <var>index</var> is not a <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-7">supported property index</a>, then return <emu-val>true</emu-val>.</p>
<li data-md="">
<p>Return <emu-val>false</emu-val>.</p>
</ol>
<li data-md="">
<p>If <var>O</var> <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-13">supports named properties</a>, <var>O</var> does not implement an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-142">interface</a> with the
[<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-103">Global</a></code>] or [<code class="idl"><a data-link-type="idl" href="#Global" id="ref-for-Global-104">PrimaryGlobal</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-107">extended attribute</a> and the result of calling the <a data-link-type="dfn" href="#dfn-named-property-visibility" id="ref-for-dfn-named-property-visibility-3">named property visibility algorithm</a> with property name <var>P</var> and object <var>O</var> is true, then:</p>
<ol>
<li data-md="">
<p>If <var>O</var> does not implement an interface with a <a data-link-type="dfn" href="#dfn-named-property-deleter" id="ref-for-dfn-named-property-deleter-5">named property deleter</a>, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>Let <var>operation</var> be the operation used to declare the named property deleter.</p>
<li data-md="">
<p>If <var>operation</var> was defined without an <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-86">identifier</a>, then:</p>
<ol>
<li data-md="">
<p>Perform the steps listed in the interface description to <a data-link-type="dfn" href="#dfn-delete-an-existing-named-property" id="ref-for-dfn-delete-an-existing-named-property-1">delete an existing named property</a> with <var>P</var> as the name.</p>
<li data-md="">
<p>If the steps indicated that the deletion failed, then return <emu-val>false</emu-val>.</p>
</ol>
<li data-md="">
<p>Otherwise, <var>operation</var> was defined with an identifier:</p>
<ol>
<li data-md="">
<p>Perform the steps listed in the description of <var>operation</var> with <var>P</var> as the only argument value.</p>
<li data-md="">
<p>If <var>operation</var> was declared with a <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-6">return type</a> of <code class="idl"><a data-link-type="idl" href="#idl-boolean" id="ref-for-idl-boolean-23">boolean</a></code> and the steps returned <emu-val>false</emu-val>, then return <emu-val>false</emu-val>.</p>
</ol>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
<li data-md="">
<p>If <var>O</var> has an own property with name <var>P</var>, then:</p>
<ol>
<li data-md="">
<p>If the property is not configurable, then return <emu-val>false</emu-val>.</p>
<li data-md="">
<p>Otherwise, remove the property from <var>O</var>.</p>
</ol>
<li data-md="">
<p>Return <emu-val>true</emu-val>.</p>
</ol>
<h4 class="heading settled" data-level="3.8.9" id="call"><span class="secno">3.8.9. </span><span class="content">Platform object [[Call]] method</span><a class="self-link" href="#call"></a></h4>
<p>The internal [[Call]] method of every <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-57">platform object</a> <var>O</var> that implements an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-143">interface</a> <var>I</var> with at least one <a data-link-type="dfn" href="#idl-legacy-callers" id="ref-for-idl-legacy-callers-8">legacy caller</a> must behave as follows, assuming <var>arg</var><sub>0..<var>n</var>−1</sub> is the list of argument
values passed to [[Call]]:</p>
<ol class="algorithm">
<li data-md="">
<p>Initialize <var>S</var> to the <a data-link-type="dfn" href="#dfn-effective-overload-set" id="ref-for-dfn-effective-overload-set-12">effective overload set</a> for legacy callers on <var>I</var> and with argument count <var>n</var>.</p>
<li data-md="">
<p>Let <<var>operation</var>, <var>values</var>> be the result of passing <var>S</var> and <var>arg</var><sub>0..<var>n</var>−1</sub> to the <a data-link-type="dfn" href="#dfn-overload-resolution-algorithm" id="ref-for-dfn-overload-resolution-algorithm-4">overload resolution algorithm</a>.</p>
<li data-md="">
<p>Perform the actions listed in the description of the legacy caller <var>operation</var> with <var>values</var> as the argument values.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-59">converting</a> the return value from those actions to an ECMAScript value of the type <var>operation</var> is declared to return (or <emu-val>undefined</emu-val> if <var>operation</var> is declared to return <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-6">void</a></code>).</p>
</ol>
<h4 class="heading settled" data-level="3.8.10" id="property-enumeration"><span class="secno">3.8.10. </span><span class="content">Property enumeration</span><a class="self-link" href="#property-enumeration"></a></h4>
<p>This document does not define a complete property enumeration order
for all <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-58">platform objects</a> implementing <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-144">interfaces</a> (or for <a href="#es-exception-objects" id="ref-for-es-exception-objects-1">platform objects representing exceptions</a>).
However, if a platform object implements an interface that <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-18">supports indexed</a> or <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-14">named properties</a>, then
properties on the object must be
enumerated in the following order:</p>
<ol>
<li data-md="">
<p>If the object <a data-link-type="dfn" href="#dfn-support-indexed-properties" id="ref-for-dfn-support-indexed-properties-19">supports indexed properties</a>, then
the object’s <a data-link-type="dfn" href="#dfn-supported-property-indices" id="ref-for-dfn-supported-property-indices-8">supported property indices</a> are
enumerated first, in numerical order.</p>
<li data-md="">
<p>If the object <a data-link-type="dfn" href="#dfn-support-named-properties" id="ref-for-dfn-support-named-properties-15">supports named properties</a> and doesn’t implement an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-145">interface</a> with the
[<code class="idl"><a data-link-type="idl" href="#LegacyUnenumerableNamedProperties" id="ref-for-LegacyUnenumerableNamedProperties-7">LegacyUnenumerableNamedProperties</a></code>] <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-108">extended attribute</a>, then
the object’s <a data-link-type="dfn" href="#dfn-supported-property-names" id="ref-for-dfn-supported-property-names-7">supported property names</a> that
are visible according to the <a data-link-type="dfn" href="#dfn-named-property-visibility" id="ref-for-dfn-named-property-visibility-4">named property visibility algorithm</a> are enumerated next, in the order given in the definition of the set of supported property names.</p>
<li data-md="">
<p>Finally, any enumerable own properties or properties from the object’s prototype chain are then enumerated,
in no defined order.</p>
</ol>
<p class="note" role="note">Note: Future versions of the ECMAScript specification may define a total order for property enumeration.</p>
<h3 class="heading settled" data-level="3.9" id="es-user-objects"><span class="secno">3.9. </span><span class="content">User objects implementing callback interfaces</span><a class="self-link" href="#es-user-objects"></a></h3>
<p>As described in <a href="#idl-objects">§2.10 Objects implementing interfaces</a>, <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-26">callback interfaces</a> can be
implemented in script by an ECMAScript object.
The following cases determine whether and how a given object
is considered to be a user object implementing a callback interface:</p>
<ul>
<li data-md="">
<p>If the interface is a <a data-link-type="dfn" href="#dfn-single-operation-callback-interface" id="ref-for-dfn-single-operation-callback-interface-1">single operation callback interface</a> (defined below) then any object apart from a native <emu-val>RegExp</emu-val> object is considered to implement the interface.
The implementation of the operation (or set of overloaded operations) is
as follows:</p>
<ul>
<li data-md="">
<p>If the object is <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">callable</a>,
then the implementation of the operation (or set of overloaded operations) is
the callable object itself.</p>
<li data-md="">
<p>Otherwise, the object is not <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">callable</a>.
The implementation of the operation (or set of overloaded operations) is
the result of invoking the internal [[Get]] method
on the object with a property name that is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-87">identifier</a> of the operation.</p>
</ul>
<li data-md="">
<p>Otherwise, the interface is not a <a data-link-type="dfn" href="#dfn-single-operation-callback-interface" id="ref-for-dfn-single-operation-callback-interface-2">single operation callback interface</a>.
Any object that is not a native <emu-val>RegExp</emu-val> object is considered to implement the interface.
For each operation declared on the interface with a given <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-88">identifier</a>, the implementation
is the result of invoking [[Get]] on the object with a
property name that is that identifier.</p>
</ul>
<p>Note that ECMAScript objects need not have
properties corresponding to <a data-link-type="dfn" href="#dfn-constant" id="ref-for-dfn-constant-29">constants</a> on them to be considered as <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-9">user objects</a> implementing <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-146">interfaces</a> that happen
to have constants declared on them.</p>
<p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-single-operation-callback-interface">single operation callback interface</dfn> is
a <a data-link-type="dfn" href="#dfn-callback-interface" id="ref-for-dfn-callback-interface-27">callback interface</a> that:</p>
<ul>
<li data-md="">
<p>is not declared to <a data-link-type="dfn" href="#dfn-inherit" id="ref-for-dfn-inherit-14">inherit</a> from another interface,</p>
<li data-md="">
<p>has no <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-77">attributes</a>, and</p>
<li data-md="">
<p>has one or more <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-18">regular operations</a> that all have the same <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-89">identifier</a>,
and no others.</p>
</ul>
<p>To <dfn data-dfn-type="dfn" data-export="" id="call-a-user-objects-operation">call a user object’s operation<a class="self-link" href="#call-a-user-objects-operation"></a></dfn>, given a <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-18">callback interface type</a> value <var>value</var>, sometimes-optional operation name <var>opName</var>,
list of argument values <var>arg</var><sub>0..<var>n</var>−1</sub> each of which is
either an IDL value or the special value “missing” (representing a missing optional
argument), and optional <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-callback-this-value">callback this value</dfn> <var>thisArg</var>, perform the following steps. These steps will either
return an IDL value or throw an exception.</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>completion</var> be an uninitialized variable.</p>
<li data-md="">
<p>If <var>thisArg</var> was not given, let <var>thisArg</var> be <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>Let <var>O</var> be the ECMAScript object corresponding to <var>value</var>.</p>
<li data-md="">
<p>Let <var>realm</var> be <var>O</var>’s <a data-link-type="dfn" href="#dfn-associated-realm" id="ref-for-dfn-associated-realm-1">associated Realm</a>.</p>
<li data-md="">
<p>Let <var>relevant settings</var> be <var>realm</var>’s <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-settings-object">settings object</a>.</p>
<li data-md="">
<p>Let <var>stored settings</var> be <var>value</var>’s <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-7">callback context</a>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-script">Prepare to run script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-a-callback">Prepare to run a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p>Determine the implementation of the operation, <var>X</var>:</p>
<ol>
<li data-md="">
<p>If <var>value</var>’s interface is a <a data-link-type="dfn" href="#dfn-single-operation-callback-interface" id="ref-for-dfn-single-operation-callback-interface-3">single operation callback interface</a> and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>O</var>) is true, then set <var>X</var> to <var>O</var>.</p>
<li data-md="">
<p>Otherwise, <var>opName</var> must be supplied:</p>
<ol>
<li data-md="">
<p>Let <var>getResult</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-get-o-p">Get</a>(<var>O</var>, <var>opName</var>).</p>
<li data-md="">
<p>If <var>getResult</var> is an abrupt completion, set <var>completion</var> to <var>getResult</var> and jump to the step labeled <a href="#call-user-object-operation-return"><i>return</i></a>.</p>
<li data-md="">
<p>Set <var>X</var> to <var>getResult</var>.[[Value]].</p>
</ol>
</ol>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>X</var>) is <emu-val>false</emu-val>,
then set <var>completion</var> to a new <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-completion-record-specification-type">Completion</a>{[[Type]]: throw, [[Value]]: a
newly created <emu-val>TypeError</emu-val> object, [[Target]]: empty}, and jump
to the step labeled <a href="#call-user-object-operation-return"><i>return</i></a>.</p>
<li data-md="">
<p>If <var>value</var>’s interface is not a <a data-link-type="dfn" href="#dfn-single-operation-callback-interface" id="ref-for-dfn-single-operation-callback-interface-4">single operation callback interface</a>,
or if <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>O</var>) is <emu-val>false</emu-val>,
set <var>thisArg</var> to <var>O</var> (overriding the provided value).</p>
<li data-md="">
<p>Let <var>esArgs</var> be an empty List of ECMAScript values.</p>
<li data-md="">
<p>Let <var>i</var> be 0.</p>
<li data-md="">
<p>Let <var>count</var> be 0.</p>
<li data-md="">
<p>While <var>i</var> < <var>n</var>:</p>
<ol>
<li data-md="">
<p>If <var>arg</var><sub><var>i</var></sub> is the special value “missing”, then
append <emu-val>undefined</emu-val> to <var>esArgs</var>.</p>
<li data-md="">
<p>Otherwise, <var>arg</var><sub><var>i</var></sub> is an IDL value:</p>
<ol>
<li data-md="">
<p>Let <var>convertResult</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-60">converting</a> <var>arg</var><sub><var>i</var></sub> to an ECMAScript value.</p>
<li data-md="">
<p>If <var>convertResult</var> is an abrupt completion, set <var>completion</var> to <var>convertResult</var> and jump to the step labeled <a href="#call-user-object-operation-return"><i>return</i></a>.</p>
<li data-md="">
<p>Append <var>convertResult</var>.[[Value]] to <var>esArgs</var>.</p>
<li data-md="">
<p>Set <var>count</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Truncate <var>esArgs</var> to have length <var>count</var>.</p>
<li data-md="">
<p>Let <var>callResult</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-call">Call</a>(<var>X</var>, <var>thisArg</var>, <var>esArgs</var>).</p>
<li data-md="">
<p>If <var>callResult</var> is an abrupt completion, set <var>completion</var> to <var>callResult</var> and jump to the step labeled <a href="#call-user-object-operation-return"><i>return</i></a>.</p>
<li data-md="">
<p>Set <var>completion</var> to the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-70">converting</a> <var>callResult</var>.[[Value]] to an IDL value of the same type as the operation’s
return type.</p>
<li data-md="">
<p><i id="call-user-object-operation-return">Return:</i> at this
point <var>completion</var> will be set to an ECMAScript completion value.</p>
<ol>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-a-callback">Clean up after running a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script">Clean up after running script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p>If <var>completion</var> is a normal completion, return <var>completion</var>.</p>
<li data-md="">
<p>If <var>completion</var> is an abrupt completion and the operation has a <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-7">return type</a> that is <em>not</em> a <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-9">promise type</a>, return <var>completion</var>.</p>
<li data-md="">
<p>Let <var>reject</var> be the initial value of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a>.reject.</p>
<li data-md="">
<p>Let <var>rejectedPromise</var> be the result of calling <var>reject</var> with <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a> as the <emu-val>this</emu-val> value and <var>completion</var>.[[Value]] as the single argument value.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-71">converting</a> <var>rejectedPromise</var> to the operation’s return type.</p>
</ol>
</ol>
<p>To <dfn data-dfn-type="dfn" data-export="" id="get-a-user-objects-attribute-value">get a user object’s attribute value<a class="self-link" href="#get-a-user-objects-attribute-value"></a></dfn>, given a <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-19">callback interface type</a> value <var>object</var> and attribute name <var>attributeName</var>,
perform the following steps. These steps will either return an IDL value or throw an
exception.</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>completion</var> be an uninitialized variable.</p>
<li data-md="">
<p>Let <var>O</var> be the ECMAScript object corresponding to <var>object</var>.</p>
<li data-md="">
<p>Let <var>realm</var> be <var>O</var>’s <a data-link-type="dfn" href="#dfn-associated-realm" id="ref-for-dfn-associated-realm-2">associated Realm</a>.</p>
<li data-md="">
<p>Let <var>relevant settings</var> be <var>realm</var>’s <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-settings-object">settings object</a>.</p>
<li data-md="">
<p>Let <var>stored settings</var> be <var>object</var>’s <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-8">callback context</a>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-script">Prepare to run script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-a-callback">Prepare to run a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p>Let <var>getResult</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-get-o-p">Get</a>(<var>O</var>, <var>attributeName</var>).</p>
<li data-md="">
<p>If <var>getResult</var> is an abrupt completion, set <var>completion</var> to <var>getResult</var> and jump to the step labeled <a href="#get-user-object-attribute-return"><i>return</i></a>.</p>
<li data-md="">
<p>Set <var>completion</var> to the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-72">converting</a> <var>getResult</var>.[[Value]] to an IDL value of the same type as the attribute’s
type.</p>
<li data-md="">
<p><i id="get-user-object-attribute-return">Return:</i> at this
point <var>completion</var> will be set to an ECMAScript completion value.</p>
<ol>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-a-callback">Clean up after running a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script">Clean up after running script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p>If <var>completion</var> is a normal completion, return <var>completion</var>.</p>
<li data-md="">
<p>If <var>completion</var> is an abrupt completion and the attribute’s type is <em>not</em> a <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-10">promise type</a>, return <var>completion</var>.</p>
<li data-md="">
<p>Let <var>reject</var> be the initial value of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a>.reject.</p>
<li data-md="">
<p>Let <var>rejectedPromise</var> be the result of calling <var>reject</var> with <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a> as the <emu-val>this</emu-val> value and <var>completion</var>.[[Value]] as the single argument value.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-73">converting</a> <var>rejectedPromise</var> to the attribute’s type.</p>
</ol>
</ol>
<p>To <dfn data-dfn-type="dfn" data-export="" id="set-a-user-objects-attribute-value">set a user object’s attribute value<a class="self-link" href="#set-a-user-objects-attribute-value"></a></dfn>, given a <a data-link-type="dfn" href="#idl-interface" id="ref-for-idl-interface-20">callback interface type</a> value <var>object</var>, attribute name <var>attributeName</var>, and
IDL value <var>value</var>, perform the following steps. These steps will not return
anything, but could throw an exception.</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>completion</var> be an uninitialized variable.</p>
<li data-md="">
<p>Let <var>O</var> be the ECMAScript object corresponding to <var>object</var>.</p>
<li data-md="">
<p>Let <var>realm</var> be <var>O</var>’s <a data-link-type="dfn" href="#dfn-associated-realm" id="ref-for-dfn-associated-realm-3">associated Realm</a>.</p>
<li data-md="">
<p>Let <var>relevant settings</var> be <var>realm</var>’s <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-settings-object">settings object</a>.</p>
<li data-md="">
<p>Let <var>stored settings</var> be <var>object</var>’s <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-9">callback context</a>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-script">Prepare to run script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-a-callback">Prepare to run a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p>Let <var>convertResult</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-61">converting</a> <var>value</var> to an
ECMAScript value.</p>
<li data-md="">
<p>If <var>convertResult</var> is an abrupt completion, set <var>completion</var> to <var>convertResult</var> and jump to the step labeled <a href="#set-user-object-attribute-return"><i>return</i></a>.</p>
<li data-md="">
<p>Set <var>completion</var> to <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-set-o-p-v-throw">Set</a>(<var>O</var>, <var>attributeName</var>, <var>convertResult</var>.[[Value]], <emu-val>true</emu-val>).</p>
<li data-md="">
<p><i id="set-user-object-attribute-return">Return:</i> at this
point <var>completion</var> will be set to an ECMAScript completion value, which is
either an abrupt completion or a normal completion for the value <emu-val>true</emu-val> (as returned by <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-set-o-p-v-throw">Set</a>).</p>
<ol>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-a-callback">Clean up after running a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script">Clean up after running script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p>If <var>completion</var> is an abrupt completion, return <var>completion</var>.</p>
<li data-md="">
<p>Return <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-normalcompletion">NormalCompletion</a>(<code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-7">void</a></code>).</p>
</ol>
</ol>
<h3 class="heading settled" data-level="3.10" id="es-invoking-callback-functions"><span class="secno">3.10. </span><span class="content">Invoking callback functions</span><a class="self-link" href="#es-invoking-callback-functions"></a></h3>
<p>An ECMAScript <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">callable</a> object that is being
used as a <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-28">callback function</a> value is
called in a manner similar to how <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-76">operations</a> on <a data-link-type="dfn" href="#dfn-user-object" id="ref-for-dfn-user-object-10">user objects</a> are called (as
described in the previous section).</p>
<p>To <dfn data-dfn-type="dfn" data-export="" id="invoke-a-callback-function">invoke<a class="self-link" href="#invoke-a-callback-function"></a></dfn> a <a data-link-type="dfn" href="#idl-callback-function" id="ref-for-idl-callback-function-6">callback function type</a> value <var>callable</var> with
a list of arguments <var>arg</var><sub>0..<var>n</var>−1</sub>, each of which is either
an IDL value or the special value “missing” (representing a missing optional argument),
and with optional <a data-link-type="dfn" href="#dfn-callback-this-value" id="ref-for-dfn-callback-this-value-2">callback this value</a> <var>thisArg</var>, perform the following steps. These steps will either
return an IDL value or throw an exception.</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>completion</var> be an uninitialized variable.</p>
<li data-md="">
<p>If <var>thisArg</var> was not given, let <var>thisArg</var> be <emu-val>undefined</emu-val>.</p>
<li data-md="">
<p>Let <var>F</var> be the ECMAScript object corresponding to <var>value</var>.</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-iscallable">IsCallable</a>(<var>F</var>) is <emu-val>false</emu-val>:</p>
<ol>
<li data-md="">
<p>If the callback function’s return type is <code class="idl"><a data-link-type="idl" href="#idl-void" id="ref-for-idl-void-8">void</a></code>,
return.</p>
<p class="note" role="note">Note: This is only possible when the callback function came from an attribute
marked with [<code class="idl"><a data-link-type="idl" href="#TreatNonObjectAsNull" id="ref-for-TreatNonObjectAsNull-10">TreatNonObjectAsNull</a></code>].</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-74">converting</a> <emu-val>undefined</emu-val> to the callback function’s return type.</p>
</ol>
<li data-md="">
<p>Let <var>realm</var> be <var>F</var>’s <a data-link-type="dfn" href="#dfn-associated-realm" id="ref-for-dfn-associated-realm-4">associated Realm</a>.</p>
<li data-md="">
<p>Let <var>relevant settings</var> be <var>realm</var>’s <a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-settings-object">settings object</a>.</p>
<li data-md="">
<p>Let <var>stored settings</var> be <var>callable</var>’s <a data-link-type="dfn" href="#dfn-callback-context" id="ref-for-dfn-callback-context-10">callback context</a>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-script">Prepare to run script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-a-callback">Prepare to run a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p>Let <var>esArgs</var> be an empty List of ECMAScript values.</p>
<li data-md="">
<p>Let <var>i</var> be 0.</p>
<li data-md="">
<p>Let <var>count</var> be 0.</p>
<li data-md="">
<p>While <var>i</var> < <var>n</var>:</p>
<ol>
<li data-md="">
<p>If <var>arg</var><sub><var>i</var></sub> is the special value “missing”, then
append <emu-val>undefined</emu-val> to <var>esArgs</var>.</p>
<li data-md="">
<p>Otherwise, <var>arg</var><sub><var>i</var></sub> is an IDL value:</p>
<ol>
<li data-md="">
<p>Let <var>convertResult</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-62">converting</a> <var>arg</var><sub><var>i</var></sub> to an ECMAScript value.</p>
<li data-md="">
<p>If <var>convertResult</var> is an abrupt completion, set <var>completion</var> to <var>convertResult</var> and jump to the step labeled <a href="#invoke-return"><i>return</i></a>.</p>
<li data-md="">
<p>Append <var>convertResult</var>.[[Value]] to <var>esArgs</var>.</p>
<li data-md="">
<p>Set <var>count</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Set <var>i</var> to <var>i</var> + 1.</p>
</ol>
<li data-md="">
<p>Truncate <var>esArgs</var> to have length <var>count</var>.</p>
<li data-md="">
<p>Let <var>callResult</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-call">Call</a>(<var>X</var>, <var>thisArg</var>, <var>esArgs</var>).</p>
<li data-md="">
<p>If <var>callResult</var> is an abrupt completion, set <var>completion</var> to <var>callResult</var> and jump to the step labeled <a href="#invoke-return"><i>return</i></a>.</p>
<li data-md="">
<p>Set <var>completion</var> to the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-75">converting</a> <var>callResult</var>.[[Value]] to an IDL value of the same type as the operation’s
return type.</p>
<li data-md="">
<p><i id="invoke-return">Return:</i> at this
point <var>completion</var> will be set to an ECMAScript completion value.</p>
<ol>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-a-callback">Clean up after running a callback</a> with <var>stored settings</var>.</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script">Clean up after running script</a> with <var>relevant settings</var>.</p>
<li data-md="">
<p>If <var>completion</var> is a normal completion, return <var>completion</var>.</p>
<li data-md="">
<p>If <var>completion</var> is an abrupt completion and the callback function has a <a data-link-type="dfn" href="#dfn-return-type" id="ref-for-dfn-return-type-8">return type</a> that is <em>not</em> a <a data-link-type="dfn" href="#dfn-promise-type" id="ref-for-dfn-promise-type-11">promise type</a>, return <var>completion</var>.</p>
<li data-md="">
<p>Let <var>reject</var> be the initial value of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a>.reject.</p>
<li data-md="">
<p>Let <var>rejectedPromise</var> be the result of calling <var>reject</var> with <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-promise-constructor">%Promise%</a> as the <emu-val>this</emu-val> value and <var>completion</var>.[[Value]] as the single argument value.</p>
<li data-md="">
<p>Return the result of <a data-link-type="dfn" href="#dfn-convert-ecmascript-to-idl-value" id="ref-for-dfn-convert-ecmascript-to-idl-value-76">converting</a> <var>rejectedPromise</var> to the callback function’s return type.</p>
</ol>
</ol>
<h3 class="heading settled" data-level="3.11" id="es-namespaces"><span class="secno">3.11. </span><span class="content">Namespaces</span><a class="self-link" href="#es-namespaces"></a></h3>
<p>For every <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-12">namespace</a> that is <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-9">exposed</a> in a given ECMAScript global environment,
a corresponding property must exist on the ECMAScript
environment’s global object. The name of the property is the <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-90">identifier</a> of the namespace, and its value is an object
called the <dfn data-dfn-type="dfn" data-export="" id="dfn-namespace-object">namespace object<a class="self-link" href="#dfn-namespace-object"></a></dfn>.</p>
<p>The property has the attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>,
[[Configurable]]: <emu-val>true</emu-val> }</span>. The characteristics of a
namespace object are described in <a href="#namespace-object">§3.11.1 Namespace object</a>.</p>
<h4 class="heading settled" data-level="3.11.1" id="namespace-object"><span class="secno">3.11.1. </span><span class="content">Namespace object</span><a class="self-link" href="#namespace-object"></a></h4>
<p>The namespace object for a given <a data-link-type="dfn" href="#dfn-namespace" id="ref-for-dfn-namespace-13">namespace</a> <var>namespace</var> and <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-code-realms">Realm</a> <var>realm</var> is created as
follows:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>namespaceObject</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-objectcreate">ObjectCreate</a>(the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-properties-of-the-object-prototype-object">%ObjectPrototype%</a> of <var>realm</var>).</p>
<li data-md="">
<p>For each <a data-link-type="dfn" href="#dfn-exposed" id="ref-for-dfn-exposed-10">exposed</a> <a data-link-type="dfn" href="#dfn-regular-operation" id="ref-for-dfn-regular-operation-19">regular operation</a> <var>op</var> that is a <a data-link-type="dfn" href="#dfn-namespace-member" id="ref-for-dfn-namespace-member-7">namespace member</a> of this namespace,</p>
<ol>
<li data-md="">
<p>Let <var>F</var> be the result of <a data-link-type="dfn" href="#dfn-create-operation-function" id="ref-for-dfn-create-operation-function-2">creating an operation function</a> given <var>op</var>, <var>namespace</var>, and <var>realm</var>.</p>
<li data-md="">
<p>Perform <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a> <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-createdataproperty">CreateDataProperty</a>(<var>namespaceObject</var>, <var>op</var>’s <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-91">identifier</a>, <var>F</var>).</p>
</ol>
</ol>
<h3 class="heading settled" data-level="3.12" id="es-exceptions"><span class="secno">3.12. </span><span class="content">Exceptions</span><a class="self-link" href="#es-exceptions"></a></h3>
<p>There must exist a property on the ECMAScript global object
whose name is “DOMException” and value is an object called the <dfn class="dfn-paneled" data-dfn-for="DOMException" data-dfn-type="dfn" data-export="" id="dfn-DOMException-constructor-object">DOMException constructor object</dfn>,
which provides access to legacy DOMException code constants and allows construction of
DOMException instances.
The property has the attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span>.</p>
<h4 class="heading settled" data-level="3.12.1" id="es-DOMException-constructor-object"><span class="secno">3.12.1. </span><span class="content">DOMException constructor object</span><a class="self-link" href="#es-DOMException-constructor-object"></a></h4>
<p>The DOMException constructor object must be a <a data-link-type="dfn" href="#dfn-function-object" id="ref-for-dfn-function-object-17">function object</a> but with a [[Prototype]] value of <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%Error%</a>.</p>
<p>For every legacy code listed in the <a href="#dfn-error-names-table" id="ref-for-dfn-error-names-table-2">error names table</a>,
there must be a property on the DOMException constructor object
whose name and value are as indicated in the table. The property has
attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span>.</p>
<p>The DOMException constructor object must also have a property named
“prototype” with attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span> whose value is an object called the <dfn class="dfn-paneled" data-dfn-for="DOMException" data-dfn-type="dfn" data-export="" id="dfn-DOMException-prototype-object">DOMException prototype object</dfn>.
This object also provides access to the legacy code values.</p>
<h5 class="heading settled" data-level="3.12.1.1" id="es-DOMException-call"><span class="secno">3.12.1.1. </span><span class="content">DOMException(message, name)</span><a class="self-link" href="#es-DOMException-call"></a></h5>
<p>When the DOMException function is called with arguments <var>message</var> and <var>name</var>, the following steps are taken:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>F</var> be the active function object.</p>
<li data-md="">
<p>If NewTarget is <emu-val>undefined</emu-val>, let <var>newTarget</var> be <var>F</var>, else let <var>newTarget</var> be NewTarget.</p>
<li data-md="">
<p>Let <var>super</var> be <var>F</var>.[[GetPrototypeOf]]().</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>super</var>).</p>
<li data-md="">
<p>If <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-isconstructor">IsConstructor</a>(<var>super</var>) is <emu-val>false</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</p>
<li data-md="">
<p>Let <var>O</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-construct">Construct</a>(<var>super</var>, «<var>message</var>», <var>newTarget</var>).</p>
<li data-md="">
<p>If <var>name</var> is not <emu-val>undefined</emu-val>, then</p>
<ol>
<li data-md="">
<p>Let <var>name</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-tostring">ToString</a>(<var>name</var>).</p>
<li data-md="">
<p>Let <var>status</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-definepropertyorthrow">DefinePropertyOrThrow</a>(<var>O</var>, <code>"name"</code>, PropertyDescriptor<span class="descriptor">{[[Value]]: <var>name</var>, [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val>}</span>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>status</var>).</p>
<li data-md="">
<p>Let <var>code</var> be the legacy code indicated in the <a data-link-type="dfn" href="#dfn-error-names-table" id="ref-for-dfn-error-names-table-3">error names table</a> for error name <var>name</var>, or <emu-val>0</emu-val> if there is none.</p>
<li data-md="">
<p>Let <var>status</var> be <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-definepropertyorthrow">DefinePropertyOrThrow</a>(<var>O</var>, <code>"code"</code>, PropertyDescriptor<span class="descriptor">{[[Value]]: <var>code</var>, [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val>}</span>).</p>
<li data-md="">
<p><a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-returnifabrupt">ReturnIfAbrupt</a>(<var>status</var>).</p>
</ol>
<li data-md="">
<p>Return <var>O</var>.</p>
</ol>
<h4 class="heading settled" data-level="3.12.2" id="es-DOMException-prototype-object"><span class="secno">3.12.2. </span><span class="content">DOMException prototype object</span><a class="self-link" href="#es-DOMException-prototype-object"></a></h4>
<p>The DOMException prototype object must
have an internal [[Prototype]] property whose value is <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%ErrorPrototype%</a>.</p>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-6">class string</a> of the <a data-link-type="dfn" href="#dfn-DOMException-prototype-object" id="ref-for-dfn-DOMException-prototype-object-2">DOMException prototype object</a> is “DOMExceptionPrototype”.</p>
<p>There must be a property named “constructor”
on the DOMException prototype object with attributes <span class="descriptor">{ [[Writable]]: <emu-val>true</emu-val>, [[Enumerable]]: <emu-val>false</emu-val>, [[Configurable]]: <emu-val>true</emu-val> }</span> and whose value is the <a data-link-type="dfn" href="#dfn-DOMException-constructor-object" id="ref-for-dfn-DOMException-constructor-object-2">DOMException constructor object</a>.</p>
<p>For every legacy code listed in the <a href="#dfn-error-names-table" id="ref-for-dfn-error-names-table-4">error names table</a>,
there must be a property on the DOMException prototype object
whose name and value are as indicated in the table. The property has
attributes <span class="descriptor">{ [[Writable]]: <emu-val>false</emu-val>, [[Enumerable]]: <emu-val>true</emu-val>, [[Configurable]]: <emu-val>false</emu-val> }</span>.</p>
<h3 class="heading settled dfn-paneled" data-dfn-type="dfn" data-level="3.13" data-lt="Exception objects" data-noexport="" id="es-exception-objects"><span class="secno">3.13. </span><span class="content">Exception objects</span></h3>
<p><a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-5">Simple exceptions</a> are represented
by native ECMAScript objects of the corresponding type.</p>
<p><code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-28">DOMExceptions</a></code> are represented by <a data-link-type="dfn" href="#dfn-platform-object" id="ref-for-dfn-platform-object-59">platform objects</a> that inherit from
the <a data-link-type="dfn" href="#dfn-DOMException-prototype-object" id="ref-for-dfn-DOMException-prototype-object-3">DOMException prototype object</a>.</p>
<p>Every platform object representing a DOMException in ECMAScript is associated with a global environment, just
as the <a data-link-type="dfn" href="#dfn-initial-object" id="ref-for-dfn-initial-object-5">initial objects</a> are.
When an exception object is created by calling the <a data-link-type="dfn" href="#dfn-DOMException-constructor-object" id="ref-for-dfn-DOMException-constructor-object-3">DOMException constructor object</a>,
either normally or as part of a <code>new</code> expression, then the global environment
of the newly created object is associated with must be the same as for the <a data-link-type="dfn" href="#dfn-DOMException-constructor-object" id="ref-for-dfn-DOMException-constructor-object-4">DOMException constructor object</a> itself.</p>
<p>The value of the internal [[Prototype]]
property of a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-29">DOMException</a></code> object must be the <a data-link-type="dfn" href="#dfn-DOMException-prototype-object" id="ref-for-dfn-DOMException-prototype-object-4">DOMException prototype object</a> from the global environment the exception object is associated with.</p>
<p>The <a data-link-type="dfn" href="#dfn-class-string" id="ref-for-dfn-class-string-7">class string</a> of a <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-30">DOMException</a></code> object
must be “DOMException”.</p>
<p class="note" role="note">Note: The intention is for DOMException objects to be just like the other
various native <emu-val>Error</emu-val> objects that the
ECMAScript specification defines, apart from responding differently
to being passed to Object.prototype.toString and it having a “code” property.
If an implementation places non-standard properties on native <emu-val>Error</emu-val> objects, exposing for example
stack traces or error line numbers, then these ought to be exposed
on exception objects too.</p>
<h3 class="heading settled" data-level="3.14" id="es-creating-throwing-exceptions"><span class="secno">3.14. </span><span class="content">Creating and throwing exceptions</span><a class="self-link" href="#es-creating-throwing-exceptions"></a></h3>
<p>First, we define the <dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-current-global-environment">current global environment</dfn> as the result of running the following algorithm:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>F</var> be the <emu-val>Function</emu-val> object used
as the <emu-val>this</emu-val> value in the top-most call
on the ECMAScript call stack where <var>F</var> corresponds to an IDL <a data-link-type="dfn" href="#dfn-attribute" id="ref-for-dfn-attribute-78">attribute</a>, <a data-link-type="dfn" href="#dfn-operation" id="ref-for-dfn-operation-77">operation</a>, <a data-link-type="dfn" href="#idl-indexed-properties" id="ref-for-idl-indexed-properties-3">indexed property</a>, <a data-link-type="dfn" href="#idl-named-properties" id="ref-for-idl-named-properties-3">named property</a>, <a href="#Constructor" id="ref-for-Constructor-23">constructor</a>, <a data-link-type="dfn" href="#dfn-named-constructor" id="ref-for-dfn-named-constructor-5">named constructor</a> or <a data-link-type="dfn" href="#dfn-stringifier" id="ref-for-dfn-stringifier-8">stringifier</a>.</p>
<li data-md="">
<p>If <var>F</var> corresponds to an attribute, operation or stringifier, then return
the global environment associated with the <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-147">interface</a> that definition appears on.</p>
<li data-md="">
<p>Otherwise, if <var>F</var> corresponds to an indexed or named property, then return
the global environment associated with the interface that
the indexed or named property getter, setter or deleter was defined on.</p>
<li data-md="">
<p>Otherwise, if <var>F</var> is a named constructor for an interface, or is
an <a data-link-type="dfn" href="#dfn-interface-object" id="ref-for-dfn-interface-object-15">interface object</a> for an
interface that is a constructor, then return the global environment
associated with that interface.</p>
<li data-md="">
<p>Otherwise, <var>F</var> is an exception field getter. Return
the global environment associated with the exception on which the
exception field was defined.</p>
</ol>
<p>When a <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-6">simple exception</a> or <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-31">DOMException</a></code> <var>E</var> is to be <a data-link-type="dfn" href="#dfn-create-exception" id="ref-for-dfn-create-exception-3">created</a>,
with <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-6">error name</a> <var>N</var> and
optional user agent-defined message <var>M</var>,
the following steps must be followed:</p>
<ol class="algorithm">
<li data-md="">
<p>If <var>M</var> was not specified, let <var>M</var> be <emu-val>undefined</emu-val>. Otherwise, let it be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-63">converting</a> <var>M</var> to a <emu-val>String</emu-val> value.</p>
<li data-md="">
<p>Let <var>N</var> be the result of <a data-link-type="dfn" href="#dfn-convert-idl-to-ecmascript-value" id="ref-for-dfn-convert-idl-to-ecmascript-value-64">converting</a> <var>N</var> to a <emu-val>String</emu-val> value.</p>
<li data-md="">
<p>Let <var>args</var> be a list of ECMAScript values.</p>
<dl class="switch">
<dt data-md="">
<p><var>E</var> is <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-32">DOMException</a></code></p>
<dd data-md="">
<p><var>args</var> is (<emu-val>undefined</emu-val>, <var>N</var>).</p>
<dt data-md="">
<p><var>E</var> is a <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-7">simple exception</a></p>
<dd data-md="">
<p><var>args</var> is (<var>M</var>)</p>
</dl>
<li data-md="">
<p>Let <var>G</var> be the <a data-link-type="dfn" href="#dfn-current-global-environment" id="ref-for-dfn-current-global-environment-2">current global environment</a>.</p>
<li data-md="">
<p>Let <var>X</var> be an object determined based on the type of <var>E</var>:</p>
<dl class="switch">
<dt data-md="">
<p><var>E</var> is <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-33">DOMException</a></code></p>
<dd data-md="">
<p><var>X</var> is the <a data-link-type="dfn" href="#dfn-DOMException-constructor-object" id="ref-for-dfn-DOMException-constructor-object-5">DOMException constructor object</a> from the global environment <var>G</var>.</p>
<dt data-md="">
<p><var>E</var> is a <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-8">simple exception</a></p>
<dd data-md="">
<p><var>X</var> is the constructor for the corresponding ECMAScript error
from the global environment <var>G</var>.</p>
</dl>
<li data-md="">
<p>Let <var>O</var> be the result of calling <var>X</var> as a function
with <var>args</var> as the argument list.</p>
<li data-md="">
<p>Return <var>O</var>.</p>
</ol>
<p>When a <a data-link-type="dfn" href="#dfn-simple-exception" id="ref-for-dfn-simple-exception-9">simple exception</a> or <code class="idl"><a data-link-type="idl" href="#dfn-DOMException" id="ref-for-dfn-DOMException-34">DOMException</a></code> <var>E</var> is to be <a data-link-type="dfn" href="#dfn-throw" id="ref-for-dfn-throw-3">thrown</a>,
with <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-7">error name</a> <var>N</var> and
optional user agent-defined message <var>M</var>,
the following steps must be followed:</p>
<ol class="algorithm">
<li data-md="">
<p>Let <var>O</var> be the result of <a data-link-type="dfn" href="#dfn-create-exception" id="ref-for-dfn-create-exception-4">creating</a> the specified exception <var>E</var> with <a data-link-type="dfn" href="#dfn-exception-error-name" id="ref-for-dfn-exception-error-name-8">error name</a> <var>N</var> and
optional user agent-defined message <var>M</var>.</p>
<li data-md="">
<p>Throw <var>O</var>.</p>
</ol>
<div class="note" role="note">
<p>The above algorithms do not restrict <a data-link-type="dfn" href="#es-exception-objects" id="ref-for-es-exception-objects-2">platform objects representing exceptions</a> propagating out of a <emu-val>Function</emu-val> to be
ones that are associated with the global environment
where that <emu-val>Function</emu-val> object originated.
For example, consider the IDL:</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">A</span> {
/**
* Calls computeSquareRoot on m, passing x as its argument.
*/
<span class="kt">double</span> <span class="nv">doComputation</span>(<span class="n">MathUtils</span> <span class="nv">m</span>, <span class="kt">double</span> <span class="nv">x</span>);
};
<span class="kt">interface</span> <span class="nv">MathUtils</span> {
/**
* If x is negative, throws a <a href="#notsupportederror" id="ref-for-notsupportederror-1">NotSupportedError</a>. Otherwise, returns
* the square root of x.
*/
<span class="kt">double</span> <span class="nv">computeSquareRoot</span>(<span class="kt">double</span> <span class="nv">x</span>);
};
</pre>
<p>If we pass a <code class="idl">MathUtils</code> object from
a different global environment to doComputation, then the exception
thrown will be from that global environment:</p>
<pre class="highlight"><span class="kd">var</span> a <span class="o">=</span> getA<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// An A object from this global environment.
</span><span class="kd">var</span> m <span class="o">=</span> otherWindow<span class="p">.</span>getMathUtils<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// A MathUtils object from a different global environment.
</span>
a <span class="k">instanceof</span> Object<span class="p">;</span> <span class="c1">// Evaluates to true.
</span>m <span class="k">instanceof</span> Object<span class="p">;</span> <span class="c1">// Evaluates to false.
</span>m <span class="k">instanceof</span> otherWindow<span class="p">.</span>Object<span class="p">;</span> <span class="c1">// Evaluates to true.
</span>
<span class="k">try</span> <span class="p">{</span>
a<span class="p">.</span>doComputation<span class="p">(</span>m<span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="p">;</span>
<span class="p">}</span> <span class="k">catch</span> <span class="p">(</span>e<span class="p">)</span> <span class="p">{</span>
e <span class="k">instanceof</span> DOMException<span class="p">;</span> <span class="c1">// Evaluates to false.
</span> e <span class="k">instanceof</span> otherWindow<span class="p">.</span>DOMException<span class="p">;</span> <span class="c1">// Evaluates to true.
</span><span class="p">}</span>
</pre>
</div>
<p>Any requirements in this document to throw an instance of an ECMAScript built-in <emu-val>Error</emu-val> must use
the built-in from the <a data-link-type="dfn" href="#dfn-current-global-environment" id="ref-for-dfn-current-global-environment-3">current global environment</a>.</p>
<h3 class="heading settled" data-level="3.15" id="es-handling-exceptions"><span class="secno">3.15. </span><span class="content">Handling exceptions</span><a class="self-link" href="#es-handling-exceptions"></a></h3>
<p>None of the algorithms or processing requirements in the
ECMAScript language binding catch ECMAScript exceptions. Whenever
an ECMAScript <emu-val>Function</emu-val> is invoked due
to requirements in this section and that <emu-val>Function</emu-val> ends due to an exception being thrown, that exception
must propagate to the caller, and if
not caught there, to its caller, and so on.</p>
<div class="example" id="example-1432e05c">
<a class="self-link" href="#example-1432e05c"></a>
<p>The following <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-45">IDL fragment</a> defines two <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-148">interfaces</a> and an <a data-link-type="dfn" href="#dfn-exception" id="ref-for-dfn-exception-1">exception</a>.
The <code>valueOf</code> attribute on <code class="idl">ExceptionThrower</code> is defined to throw an exception whenever an attempt is made
to get its value.</p>
<pre class="highlight"><span class="kt">interface</span> <span class="nv">Dahut</span> {
<span class="kt">attribute</span> <span class="kt">DOMString</span> <span class="nv">type</span>;
};
<span class="kt">interface</span> <span class="nv">ExceptionThrower</span> {
// This attribute always throws a NotSupportedError and never returns a value.
<span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">valueOf</span>;
};
</pre>
<p>Assuming an ECMAScript implementation supporting this interface,
the following code demonstrates how exceptions are handled:</p>
<pre class="highlight"><span class="kd">var</span> d <span class="o">=</span> getDahut<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of Dahut.
</span><span class="kd">var</span> et <span class="o">=</span> getExceptionThrower<span class="p">(</span><span class="p">)</span><span class="p">;</span> <span class="c1">// Obtain an instance of ExceptionThrower.
</span>
<span class="k">try</span> <span class="p">{</span>
d<span class="p">.</span>type <span class="o">=</span> <span class="p">{</span> toString<span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> <span class="k">throw</span> <span class="s2">"abc"</span><span class="p">;</span> <span class="p">}</span> <span class="p">}</span><span class="p">;</span>
<span class="p">}</span> <span class="k">catch</span> <span class="p">(</span>e<span class="p">)</span> <span class="p">{</span>
<span class="c1">// The string "abc" is caught here, since as part of the conversion
</span> <span class="c1">// from the native object to a string, the anonymous function
</span> <span class="c1">// was invoked, and none of the [[DefaultValue]], ToPrimitive or
</span> <span class="c1">// ToString algorithms are defined to catch the exception.
</span><span class="p">}</span>
<span class="k">try</span> <span class="p">{</span>
d<span class="p">.</span>type <span class="o">=</span> <span class="p">{</span> toString<span class="o">:</span> <span class="p">{</span> <span class="p">}</span> <span class="p">}</span><span class="p">;</span>
<span class="p">}</span> <span class="k">catch</span> <span class="p">(</span>e<span class="p">)</span> <span class="p">{</span>
<span class="c1">// An exception is caught here, since an attempt is made to invoke
</span> <span class="c1">// [[Call]] on the native object that is the value of toString
</span> <span class="c1">// property.
</span><span class="p">}</span>
d<span class="p">.</span>type <span class="o">=</span> et<span class="p">;</span>
<span class="c1">// An uncaught NotSupportedError DOMException is thrown here, since the
</span><span class="c1">// [[DefaultValue]] algorithm attempts to get the value of the
</span><span class="c1">// "valueOf" property on the ExceptionThrower object. The exception
</span><span class="c1">// propagates out of this block of code.
</span></pre>
</div>
<h2 class="heading settled" data-level="4" id="common"><span class="secno">4. </span><span class="content">Common definitions</span><a class="self-link" href="#common"></a></h2>
<p>This section specifies some common definitions that all <a data-link-type="dfn" href="#dfn-conforming-implementation" id="ref-for-dfn-conforming-implementation-1">conforming implementations</a> must support.</p>
<h3 class="heading settled dfn-paneled idl-code" data-dfn-type="typedef" data-export="" data-level="4.1" data-lt="ArrayBufferView" id="ArrayBufferView"><span class="secno">4.1. </span><span class="content">ArrayBufferView</span><span id="common-ArrayBufferView"></span></h3>
<pre class="idl highlight def"><span class="kt">typedef</span> (<span class="kt">Int8Array</span> <span class="kt">or</span> <span class="kt">Int16Array</span> <span class="kt">or</span> <span class="kt">Int32Array</span> <span class="kt">or</span>
<span class="kt">Uint8Array</span> <span class="kt">or</span> <span class="kt">Uint16Array</span> <span class="kt">or</span> <span class="kt">Uint32Array</span> <span class="kt">or</span> <span class="kt">Uint8ClampedArray</span> <span class="kt">or</span>
<span class="kt">Float32Array</span> <span class="kt">or</span> <span class="kt">Float64Array</span> <span class="kt">or</span> <span class="kt">DataView</span>) <a class="nv idl-code" data-link-type="typedef" href="#ArrayBufferView" id="ref-for-ArrayBufferView-1">ArrayBufferView</a>;
</pre>
<p>The <code class="idl"><a data-link-type="idl" href="#ArrayBufferView" id="ref-for-ArrayBufferView-2">ArrayBufferView</a></code> typedef is used to represent
objects that provide a view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-18">ArrayBuffer</a></code>.</p>
<h3 class="heading settled dfn-paneled idl-code" data-dfn-type="typedef" data-export="" data-level="4.2" data-lt="BufferSource" id="BufferSource"><span class="secno">4.2. </span><span class="content">BufferSource</span><span id="common-BufferSource"></span></h3>
<pre class="idl highlight def"><span class="kt">typedef</span> (<a class="n" data-link-type="idl-name" href="#ArrayBufferView" id="ref-for-ArrayBufferView-3">ArrayBufferView</a> <span class="kt">or</span> <span class="kt">ArrayBuffer</span>) <a class="nv idl-code" data-link-type="typedef" href="#BufferSource" id="ref-for-BufferSource-2">BufferSource</a>;</pre>
<p>The <code class="idl"><a data-link-type="idl" href="#BufferSource" id="ref-for-BufferSource-3">BufferSource</a></code> typedef is used to represent objects
that are either themselves an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-19">ArrayBuffer</a></code> or which
provide a view on to an <code class="idl"><a data-link-type="idl" href="#idl-ArrayBuffer" id="ref-for-idl-ArrayBuffer-20">ArrayBuffer</a></code>.</p>
<h3 class="heading settled dfn-paneled idl-code" data-dfn-type="typedef" data-export="" data-level="4.3" data-lt="DOMTimeStamp" id="DOMTimeStamp"><span class="secno">4.3. </span><span class="content">DOMTimeStamp</span><span id="common-DOMTimeStamp"></span></h3>
<pre class="idl highlight def"><span class="kt">typedef</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">long</span> <a class="nv idl-code" data-link-type="typedef" href="#DOMTimeStamp" id="ref-for-DOMTimeStamp-1">DOMTimeStamp</a>;</pre>
<p>The <code class="idl"><a data-link-type="idl" href="#DOMTimeStamp" id="ref-for-DOMTimeStamp-2">DOMTimeStamp</a></code> type is used for representing
a number of milliseconds, either as an absolute time (relative to some epoch)
or as a relative amount of time. Specifications that use this type will need
to define how the number of milliseconds is to be interpreted.</p>
<h3 class="heading settled dfn-paneled idl-code" data-dfn-type="callback" data-export="" data-level="4.4" data-lt="Function" id="Function"><span class="secno">4.4. </span><span class="content">Function</span><span id="common-Function"></span></h3>
<pre class="idl highlight def"><span class="kt">callback</span> <a class="nv idl-code" data-link-type="callback" href="#Function" id="ref-for-Function-1">Function</a> = <span class="kt">any</span> (<span class="kt">any</span>... <dfn class="nv idl-code" data-dfn-for="Function" data-dfn-type="argument" data-export="" id="dom-function-arguments">arguments<a class="self-link" href="#dom-function-arguments"></a></dfn>);</pre>
<p>The <code class="idl"><a data-link-type="idl" href="#Function" id="ref-for-Function-2">Function</a></code> <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-29">callback function</a> type is used for representing function values with no restriction on what arguments
are passed to it or what kind of value is returned from it.</p>
<h3 class="heading settled dfn-paneled idl-code" data-dfn-type="callback" data-export="" data-level="4.5" data-lt="VoidFunction" id="VoidFunction"><span class="secno">4.5. </span><span class="content">VoidFunction</span></h3>
<pre class="idl highlight def"><span class="kt">callback</span> <a class="nv idl-code" data-link-type="callback" href="#VoidFunction" id="ref-for-VoidFunction-1">VoidFunction</a> = <span class="kt">void</span> ();</pre>
<p>The <code class="idl"><a data-link-type="idl" href="#VoidFunction" id="ref-for-VoidFunction-2">VoidFunction</a></code> <a data-link-type="dfn" href="#dfn-callback-function" id="ref-for-dfn-callback-function-30">callback function</a> type is used for representing function values that take no arguments and do not
return any value.</p>
<h2 class="heading settled" data-level="5" id="extensibility"><span class="secno">5. </span><span class="content">Extensibility</span><a class="self-link" href="#extensibility"></a></h2>
<p><i>This section is informative.</i></p>
<p>Extensions to language binding requirements can be specified
using <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-109">extended attributes</a> that do not conflict with those defined in this document. Extensions for
private, project-specific use should not be included in <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-46">IDL fragments</a> appearing in other specifications. It is recommended that extensions
that are required for use in other specifications be coordinated
with the group responsible for work on <cite>Web IDL</cite>, which
at the time of writing is the <a href="http://www.w3.org/WebPlatform/WG/">W3C Web Platform Working Group</a>,
for possible inclusion in a future version of this document.</p>
<p>Extensions to any other aspect of the IDL language are
strongly discouraged.</p>
<h2 class="heading settled" data-level="6" id="referencing"><span class="secno">6. </span><span class="content">Referencing this specification</span><a class="self-link" href="#referencing"></a></h2>
<p><i>This section is informative.</i></p>
<p>It is expected that other specifications that define Web platform interfaces
using one or more <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-47">IDL fragments</a> will reference this specification. It is suggested
that those specifications include a sentence such as the following,
to indicate that the IDL is to be interpreted as described in this
specification:</p>
<blockquote>
<p>The IDL fragment in Appendix A of this specification must, in conjunction
with the IDL fragments defined in this specification’s normative references,
be interpreted as required for <em>conforming sets of IDL fragments</em>, as described in the
“Web IDL” specification. [WEBIDL]</p>
</blockquote>
<p>In addition, it is suggested that the conformance class for user
agents in referencing specifications be linked to the <a data-link-type="dfn" href="#dfn-conforming-implementation" id="ref-for-dfn-conforming-implementation-2">conforming implementation</a> class from this specification:</p>
<blockquote>
<p>A conforming FooML user agent must also be a <em>conforming implementation</em> of the IDL fragment in Appendix A
of this specification, as described in the
“Web IDL” specification. [WEBIDL]</p>
</blockquote>
<h2 class="heading settled" data-level="7" id="acknowledgements"><span class="secno">7. </span><span class="content">Acknowledgements</span><a class="self-link" href="#acknowledgements"></a></h2>
<p><i>This section is informative.</i></p>
<p>The editor would like to thank the following people for contributing
to this specification:
Glenn Adams,
David Andersson,
L. David Baron,
Art Barstow,
Nils Barth,
Robin Berjon,
David Bruant,
Jan-Ivar Bruaroey,
Marcos Cáceres,
Giovanni Campagna,
Domenic Denicola,
Chris Dumez,
Michael Dyck,
Brendan Eich,
João Eiras,
Gorm Haug Eriksen,
Sigbjorn Finne,
David Flanagan,
Aryeh Gregor,
Dimitry Golubovsky,
James Graham,
Aryeh Gregor,
Kartikaya Gupta,
Marcin Hanclik,
Jed Hartman,
Stefan Haustein,
Dominique Hazaël-Massieux,
Ian Hickson,
Björn Höhrmann,
Kyle Huey,
Lachlan Hunt,
Oliver Hunt,
Jim Jewett,
Wolfgang Keller,
Anne van Kesteren,
Olav Junker Kjær,
Magnus Kristiansen,
Takeshi Kurosawa,
Yves Lafon,
Travis Leithead,
Jim Ley,
Kevin Lindsey,
Jens Lindström,
Peter Linss,
呂康豪 (Kang-Hao Lu),
Kyle Machulis,
Mark Miller,
Ms2ger,
Andrew Oakley,
岡坂 史紀 (Shiki Okasaka),
Jason Orendorff,
Olli Pettay,
Simon Pieters,
Andrei Popescu,
François Remy,
Tim Renouf,
Alex Russell,
Takashi Sakamoto,
Doug Schepers,
Jonas Sicking,
Garrett Smith,
Geoffrey Sneddon,
Jungkee Song,
Josh Soref,
Maciej Stachowiak,
Anton Tayanovskyy,
Peter Van der Beken,
Jeff Walden,
Allen Wirfs-Brock,
Jeffrey Yasskin and
Collin Xu.</p>
<p>Special thanks also go to Sam Weinig for maintaining this document
while the editor was unavailable to do so.</p>
<h2 class="no-num heading settled" id="idl-grammar"><span class="content">IDL grammar</span><a class="self-link" href="#idl-grammar"></a></h2>
<p>This section defines an LL(1) grammar whose start symbol, <emu-nt><a href="#prod-Definitions">Definitions</a></emu-nt>, matches an
entire <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-48">IDL fragment</a>.</p>
<p>Each production in the grammar has on its right hand side either a
non-zero sequence of terminal and non-terminal symbols, or an
epsilon (ε) which indicates no symbols.
Symbols that begin with an uppercase letter are non-terminal symbols.
Symbols in monospaced fonts are terminal symbols.
Symbols in sans-serif font that begin with a lowercase letter are terminal
symbols that are matched by the regular expressions (using Perl 5 regular
expression syntax <a data-link-type="biblio" href="#biblio-perlre">[PERLRE]</a>) as follows:</p>
<table class="grammar data">
<tbody>
<tr>
<td id="prod-integer"><emu-t class="symbol">integer</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>-?([1-9][0-9]*|0[Xx][0-9A-Fa-f]+|0[0-7]*)<span class="mute">/</span></code>
<tr>
<td id="prod-float"><emu-t class="symbol">float</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>-?(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][+-]?[0-9]+)?|[0-9]+[Ee][+-]?[0-9]+)<span class="mute">/</span></code>
<tr>
<td id="prod-identifier"><emu-t class="symbol">identifier</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>_?[A-Za-z][0-9A-Z_a-z-]*<span class="mute">/</span></code>
<tr>
<td id="prod-string"><emu-t class="symbol">string</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>"[^"]*"<span class="mute">/</span></code>
<tr>
<td id="prod-whitespace"><emu-t class="symbol">whitespace</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>[\t\n\r ]+<span class="mute">/</span></code>
<tr>
<td id="prod-comment"><emu-t class="symbol">comment</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>\/\/.*|\/\*(.|\n)*?\*\/<span class="mute">/</span></code>
<tr>
<td id="prod-other"><emu-t class="symbol">other</emu-t>
<td><code class="regex">=</code>
<td><code class="regex"><span class="mute">/</span>[^\t\n\r 0-9A-Za-z]<span class="mute">/</span></code>
</table>
<p>The tokenizer operates on a sequence of Unicode characters <a data-link-type="biblio" href="#biblio-unicode">[UNICODE]</a>.
When tokenizing, the longest possible match must be used. For example, if the input
text is “<span class="input">a1</span>”, it is tokenized as a single <emu-t><a href="#prod-identifier">identifier</a></emu-t>,
and not as a separate <emu-t><a href="#prod-identifier">identifier</a></emu-t> and <emu-t><a href="#prod-integer">integer</a></emu-t>.
If the longest possible match could match one of the above named terminal symbols or
one of the other terminal symbols from the grammar, it must be tokenized as the latter.
Thus, the input text “<span class="input">long</span>” is tokenized as the quoted terminal symbol <emu-t>long</emu-t> rather than an <emu-t><a href="#prod-identifier">identifier</a></emu-t> called “long”,
and “<span class="input">.</span>” is tokenized as the quoted terminal symbol <emu-t>.</emu-t> rather than an <emu-t><a href="#prod-other">other</a></emu-t>.</p>
<p>The IDL syntax is case sensitive, both for the quoted terminal symbols
used in the grammar and the values used for <emu-t><a href="#prod-identifier">identifier</a></emu-t> terminals. Thus, for
example, the input text “<span class="input">Const</span>” is tokenized as
an <emu-t><a href="#prod-identifier">identifier</a></emu-t> rather than the
terminal symbol <emu-t>const</emu-t>, an <a data-link-type="dfn" href="#dfn-interface" id="ref-for-dfn-interface-149">interface</a> with <a data-link-type="dfn" href="#dfn-identifier" id="ref-for-dfn-identifier-92">identifier</a> “A” is distinct from one named “a”, and an <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-110">extended attribute</a> [<code class="idl">constructor</code>] will not be recognized as
the [<code class="idl"><a data-link-type="idl" href="#Constructor" id="ref-for-Constructor-24">Constructor</a></code>]
extended attribute.</p>
<p>Implicitly, any number of <emu-t><a href="#prod-whitespace">whitespace</a></emu-t> and <emu-t><a href="#prod-comment">comment</a></emu-t> terminals are allowed between every other terminal
in the input text being parsed. Such <emu-t><a href="#prod-whitespace">whitespace</a></emu-t> and <emu-t><a href="#prod-comment">comment</a></emu-t> terminals are ignored while parsing.</p>
<p>The following LL(1) grammar, starting with <emu-nt><a href="#prod-Definitions">Definitions</a></emu-nt>,
matches an <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-49">IDL fragment</a>:</p>
<div data-fill-with="grammar-index"></div>
<p class="note" role="note">Note: The <emu-nt><a href="#prod-Other">Other</a></emu-nt> non-terminal matches any single terminal symbol except for <emu-t>(</emu-t>, <emu-t>)</emu-t>, <emu-t>[</emu-t>, <emu-t>]</emu-t>, <emu-t>{</emu-t>, <emu-t>}</emu-t> and <emu-t>,</emu-t>.</p>
<p>While the <emu-nt><a href="#prod-ExtendedAttribute">ExtendedAttribute</a></emu-nt> non-terminal matches any non-empty sequence of terminal symbols (as long as any
parentheses, square brackets or braces are balanced, and the <emu-t>,</emu-t> token appears only within those balanced brackets),
only a subset of those
possible sequences are used by the <a data-link-type="dfn" href="#dfn-extended-attribute" id="ref-for-dfn-extended-attribute-111">extended attributes</a> defined in this specification — see <a href="#idl-extended-attributes">§2.12 Extended attributes</a> for the syntaxes that are used by these extended attributes.</p>
<h2 class="no-num heading settled" id="conventions"><span class="content">Document conventions</span><a class="self-link" href="#conventions"></a></h2>
<p>The following typographic conventions are used in this document:</p>
<ul>
<li data-md="">
<p>Defining instances of terms: <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="dfn-example-term">example term</dfn></p>
<li data-md="">
<p>Links to terms defined in this document or elsewhere: <a data-link-type="dfn" href="#dfn-example-term" id="ref-for-dfn-example-term-1">example term</a></p>
<li data-md="">
<p>Grammar terminals: <emu-t>sometoken</emu-t></p>
<li data-md="">
<p>Grammar non-terminals: <emu-nt>ExampleGrammarNonTerminal</emu-nt></p>
<li data-md="">
<p>Grammar symbols: <emu-t class="symbol">identifier</emu-t></p>
<li data-md="">
<p>IDL and ECMAScript types: <code class="idl">ExampleType</code></p>
<li data-md="">
<p>Code snippets: <code>a = b + obj.f()</code></p>
<li data-md="">
<p>Unicode characters: <span class="char">U+0030 DIGIT ZERO ("0")</span></p>
<li data-md="">
<p>Extended attributes: [<code class="idl">ExampleExtendedAttribute</code>]</p>
<li data-md="">
<p>Variable names in prose and algorithms: <var>exampleVariableName</var>.</p>
<li data-md="">
<p>Algorithms use the <a data-link-type="dfn" href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">conventions of the ECMAScript specification</a>,
including the ! and ? notation for unwrapping completion records.</p>
<li data-md="">
<p>IDL informal syntax examples:</p>
<pre class="syntax highlight"><span class="kt">interface</span> <span class="nv">identifier</span> {
<mark>/* interface_members... */</mark>
};
</pre>
<p>(Specific parts of the syntax discussed in surrounding prose are <mark>highlighted</mark>.)</p>
<li data-md="">
<p>IDL grammar snippets:</p>
<pre class="grammar no-index">ExampleGrammarNonTerminal :
OtherNonTerminal "sometoken"
other AnotherNonTerminal
ε // nothing
</pre>
<li data-md="">
<p>Non-normative notes:</p>
<p class="note" role="note">Note: This is a note.</p>
<li data-md="">
<p>Non-normative examples:</p>
<div class="example" id="example-263fb1aa"><a class="self-link" href="#example-263fb1aa"></a> This is an example. </div>
<li data-md="">
<p>Normative warnings:</p>
<p class="advisement"> This is a warning. </p>
<li data-md="">
<p>Code blocks:</p>
<pre class="highlight">// This is an IDL code block.
<span class="kt">interface</span> <span class="nv">Example</span> {
<span class="kt">attribute</span> <span class="kt">long</span> <span class="nv">something</span>;
};
</pre>
<pre class="highlight"><span class="c1">// This is an ECMAScript code block.
</span>window<span class="p">.</span>onload <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span> window<span class="p">.</span>alert<span class="p">(</span><span class="s2">"loaded"</span><span class="p">)</span><span class="p">;</span> <span class="p">}</span><span class="p">;</span>
</pre>
</ul>
<h2 class="no-num heading settled" id="conformance"><span class="content">Conformance</span><span id="conformant-algorithms"></span><a class="self-link" href="#conformance"></a></h2>
<p>Everything in this specification is normative except for diagrams,
examples, notes and sections marked as being informative.</p>
<p>The keywords “must”,
“must not”,
“required”,
“shall”,
“shall not”,
“should”,
“should not”,
“recommended”,
“may” and
“optional” in this document are to be
interpreted as described in <cite><a href="http://tools.ietf.org/html/rfc2119">Key words for use in RFCs to
Indicate Requirement Levels</a></cite> <a data-link-type="biblio" href="#biblio-rfc2119">[RFC2119]</a>.</p>
<p>Requirements phrased in the imperative as part of algorithms (such as
“strip any leading space characters” or “return false and abort these
steps”) are to be interpreted with the meaning of the key word (“must”,
“should”, “may”, etc) used in introducing the algorithm.</p>
<p>Conformance requirements phrased as algorithms or specific steps can be
implemented in any manner, so long as the end result is <dfn data-dfn-type="dfn" data-lt="processing equivalence" data-noexport="" id="dfn-processing-equivalence">equivalent<a class="self-link" href="#dfn-processing-equivalence"></a></dfn>. In
particular, the algorithms defined in this specification are intended to
be easy to understand and are not intended to be performant. Implementers
are encouraged to optimize.</p>
<p>The following conformance classes are defined by this specification:</p>
<dl>
<dt data-md="">
<p><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-conforming-set-of-idl-fragments">conforming set of IDL fragments</dfn></p>
<dd data-md="">
<p>A set of <a data-link-type="dfn" href="#dfn-idl-fragment" id="ref-for-dfn-idl-fragment-50">IDL fragments</a> is considered
to be a <a data-link-type="dfn" href="#dfn-conforming-set-of-idl-fragments" id="ref-for-dfn-conforming-set-of-idl-fragments-1">conforming set of IDL fragments</a> if, taken together, they satisfy all of the
must-,
required- and shall-level
criteria in this specification that apply to IDL fragments.</p>
<dt data-md="">
<p><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-conforming-implementation">conforming implementation</dfn></p>
<dd data-md="">
<p>A user agent is considered to be a <a data-link-type="dfn" href="#dfn-conforming-implementation" id="ref-for-dfn-conforming-implementation-3">conforming implementation</a> relative to a <a data-link-type="dfn" href="#dfn-conforming-set-of-idl-fragments" id="ref-for-dfn-conforming-set-of-idl-fragments-2">conforming set of IDL fragments</a> if it satisfies all of the must-,
required- and shall-level
criteria in this specification that apply to implementations for all language
bindings that the user agent supports.</p>
<dt data-md="">
<p><dfn class="dfn-paneled" data-dfn-type="dfn" data-export="" id="dfn-conforming-ecmascript-implementation">conforming ECMAScript implementation</dfn></p>
<dd data-md="">
<p>A user agent is considered to be a <a data-link-type="dfn" href="#dfn-conforming-ecmascript-implementation" id="ref-for-dfn-conforming-ecmascript-implementation-1">conforming ECMAScript implementation</a> relative to a <a data-link-type="dfn" href="#dfn-conforming-set-of-idl-fragments" id="ref-for-dfn-conforming-set-of-idl-fragments-3">conforming set of IDL fragments</a> if it satisfies all of the must-,
required- and shall-level
criteria in this specification that apply to implementations for the ECMAScript
language binding.</p>
<script>
// Grammar
(function() {
function wrap(s) { return "<pre class=grammar>" + s + "</pre>"; }
var output = "";
[].forEach.call(document.querySelectorAll("pre.grammar"), pre => {
var html = pre.textContent.replace(/("[^"]+")|([a-zA-Z]+)|(:)/g, m => {
if (/^"/.test(m)) { return "<emu-t>" + m.replace(/^"|"$/g, "") + "</emu-t>"; }
if (/^(integer|float|identifier|string|whitespace|comment|other)$/.test(m)) {
return "<emu-t class=\"symbol\"><a href=\"#prod-" + m + "\">" + m + "</a></emu-t>";
}
if (m == ":") { return "::"; }
if (document.querySelector("#prod-" + m)) {
return "<emu-nt><a href=\"#prod-" + m + "\">" + m + "</a></emu-nt>";
}
return "<emu-nt>" + m + "</emu-nt>"
});
pre.innerHTML = html;
var fillWith = document.querySelectorAll("div[data-fill-with=\"grammar-" + pre.id.replace("prod-", "") + "\"]");
[].forEach.call(fillWith, div => div.innerHTML = wrap(html))
if (!(/\bno-index\b/).test(pre.className)) {
output += html + "\n";
}
});
document.querySelector("div[data-fill-with=\"grammar-index\"]").innerHTML = wrap(output);
})();
// Rotated Table Headers
/*! modernizr 3.3.1 (Custom Build) | MIT *
* https://modernizr.com/download/?-csstransforms-setclasses !*/
!function(e,n,t){function r(e,n){return typeof e===n}function o(){var e,n,t,o,s,i,a;for(var l in C)if(C.hasOwnProperty(l)){if(e=[],n=C[l],n.name&&(e.push(n.name.toLowerCase()),n.options&&n.options.aliases&&n.options.aliases.length))for(t=0;t<n.options.aliases.length;t++)e.push(n.options.aliases[t].toLowerCase());for(o=r(n.fn,"function")?n.fn():n.fn,s=0;s<e.length;s++)i=e[s],a=i.split("."),1===a.length?Modernizr[a[0]]=o:(!Modernizr[a[0]]||Modernizr[a[0]]instanceof Boolean||(Modernizr[a[0]]=new Boolean(Modernizr[a[0]])),Modernizr[a[0]][a[1]]=o),g.push((o?"":"no-")+a.join("-"))}}function s(e){var n=_.className,t=Modernizr._config.classPrefix||"";if(S&&(n=n.baseVal),Modernizr._config.enableJSClass){var r=new RegExp("(^|\\s)"+t+"no-js(\\s|$)");n=n.replace(r,"$1"+t+"js$2")}Modernizr._config.enableClasses&&(n+=" "+t+e.join(" "+t),S?_.className.baseVal=n:_.className=n)}function i(e,n){return!!~(""+e).indexOf(n)}function a(){return"function"!=typeof n.createElement?n.createElement(arguments[0]):S?n.createElementNS.call(n,"http://www.w3.org/2000/svg",arguments[0]):n.createElement.apply(n,arguments)}function l(e){return e.replace(/([a-z])-([a-z])/g,function(e,n,t){return n+t.toUpperCase()}).replace(/^-/,"")}function f(e,n){return function(){return e.apply(n,arguments)}}function u(e,n,t){var o;for(var s in e)if(e[s]in n)return t===!1?e[s]:(o=n[e[s]],r(o,"function")?f(o,t||n):o);return!1}function d(e){return e.replace(/([A-Z])/g,function(e,n){return"-"+n.toLowerCase()}).replace(/^ms-/,"-ms-")}function c(){var e=n.body;return e||(e=a(S?"svg":"body"),e.fake=!0),e}function p(e,t,r,o){var s,i,l,f,u="modernizr",d=a("div"),p=c();if(parseInt(r,10))for(;r--;)l=a("div"),l.id=o?o[r]:u+(r+1),d.appendChild(l);return s=a("style"),s.type="text/css",s.id="s"+u,(p.fake?p:d).appendChild(s),p.appendChild(d),s.styleSheet?s.styleSheet.cssText=e:s.appendChild(n.createTextNode(e)),d.id=u,p.fake&&(p.style.background="",p.style.overflow="hidden",f=_.style.overflow,_.style.overflow="hidden",_.appendChild(p)),i=t(d,e),p.fake?(p.parentNode.removeChild(p),_.style.overflow=f,_.offsetHeight):d.parentNode.removeChild(d),!!i}function m(n,r){var o=n.length;if("CSS"in e&&"supports"in e.CSS){for(;o--;)if(e.CSS.supports(d(n[o]),r))return!0;return!1}if("CSSSupportsRule"in e){for(var s=[];o--;)s.push("("+d(n[o])+":"+r+")");return s=s.join(" or "),p("@supports ("+s+") { #modernizr { position: absolute; } }",function(e){return"absolute"==getComputedStyle(e,null).position})}return t}function h(e,n,o,s){function f(){d&&(delete z.style,delete z.modElem)}if(s=r(s,"undefined")?!1:s,!r(o,"undefined")){var u=m(e,o);if(!r(u,"undefined"))return u}for(var d,c,p,h,v,y=["modernizr","tspan","samp"];!z.style&&y.length;)d=!0,z.modElem=a(y.shift()),z.style=z.modElem.style;for(p=e.length,c=0;p>c;c++)if(h=e[c],v=z.style[h],i(h,"-")&&(h=l(h)),z.style[h]!==t){if(s||r(o,"undefined"))return f(),"pfx"==n?h:!0;try{z.style[h]=o}catch(g){}if(z.style[h]!=v)return f(),"pfx"==n?h:!0}return f(),!1}function v(e,n,t,o,s){var i=e.charAt(0).toUpperCase()+e.slice(1),a=(e+" "+b.join(i+" ")+i).split(" ");return r(n,"string")||r(n,"undefined")?h(a,n,o,s):(a=(e+" "+E.join(i+" ")+i).split(" "),u(a,n,t))}function y(e,n,r){return v(e,t,t,n,r)}var g=[],C=[],w={_version:"3.3.1",_config:{classPrefix:"",enableClasses:!0,enableJSClass:!0,usePrefixes:!0},_q:[],on:function(e,n){var t=this;setTimeout(function(){n(t[e])},0)},addTest:function(e,n,t){C.push({name:e,fn:n,options:t})},addAsyncTest:function(e){C.push({name:null,fn:e})}},Modernizr=function(){};Modernizr.prototype=w,Modernizr=new Modernizr;var _=n.documentElement,S="svg"===_.nodeName.toLowerCase(),x="Moz O ms Webkit",b=w._config.usePrefixes?x.split(" "):[];w._cssomPrefixes=b;var E=w._config.usePrefixes?x.toLowerCase().split(" "):[];w._domPrefixes=E;var P={elem:a("modernizr")};Modernizr._q.push(function(){delete P.elem});var z={style:P.elem.style};Modernizr._q.unshift(function(){delete z.style}),w.testAllProps=v,w.testAllProps=y,Modernizr.addTest("csstransforms",function(){return-1===navigator.userAgent.indexOf("Android 2.")&&y("transform","scale(1)",!0)}),o(),s(g),delete w.addTest,delete w.addAsyncTest;for(var N=0;N<Modernizr._q.length;N++)Modernizr._q[N]();e.Modernizr=Modernizr}(window,document);
</script>
</dl>
</main>
<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
<h2 class="no-num no-ref heading settled" id="index"><span class="content">Index</span><a class="self-link" href="#index"></a></h2>
<h3 class="no-num no-ref heading settled" id="index-defined-here"><span class="content">Terms defined by this specification</span><a class="self-link" href="#index-defined-here"></a></h3>
<ul class="index">
<li><a href="#dom-domexception-abort_err">ABORT_ERR</a><span>, in §2.5.1</span>
<li><a href="#aborterror">AbortError</a><span>, in §2.5.1</span>
<li><a href="#idl-any">any</a><span>, in §2.11</span>
<li><a href="#idl-ArrayBuffer">ArrayBuffer</a><span>, in §2.11.31</span>
<li><a href="#ArrayBufferView">ArrayBufferView</a><span>, in §4</span>
<li><a href="#dfn-array-index-property-name">array index property name</a><span>, in §3.8.1</span>
<li><a href="#dfn-associated-realm">associated Realm</a><span>, in §3.1</span>
<li><a href="#dfn-attribute">attribute</a><span>, in §2.2.2</span>
<li><a href="#dfn-attribute-getter">attribute getter</a><span>, in §3.6.6</span>
<li><a href="#dfn-attribute-setter">attribute setter</a><span>, in §3.6.6</span>
<li><a href="#dfn-available-only-in-secure-contexts">available only in secure contexts</a><span>, in §3.3.17</span>
<li><a href="#idl-boolean">boolean</a><span>, in §2.11.1</span>
<li><a href="#BufferSource">BufferSource</a><span>, in §4.1</span>
<li><a href="#dfn-buffer-source-type">buffer source types</a><span>, in §2.11</span>
<li><a href="#idl-byte">byte</a><span>, in §2.11.2</span>
<li><a href="#idl-ByteString">ByteString</a><span>, in §2.11.15</span>
<li><a href="#call-a-user-objects-operation">call a user object’s operation</a><span>, in §3.9</span>
<li><a href="#dfn-callback-context">callback context</a><span>, in §2.11.19</span>
<li><a href="#dfn-callback-function">callback function</a><span>, in §2.7</span>
<li><a href="#idl-callback-function">Callback function types</a><span>, in §2.11.21</span>
<li><a href="#dfn-callback-interface">callback interface</a><span>, in §2.2</span>
<li><a href="#dfn-callback-this-value">callback this value</a><span>, in §3.9</span>
<li><a href="#dfn-change-global-environment">change</a><span>, in §3.8</span>
<li><a href="#Clamp">Clamp</a><span>, in §3.3</span>
<li><a href="#dfn-class-string">class string</a><span>, in §3</span>
<li><a href="#dfn-code-unit">code units</a><span>, in §2.2.3</span>
<li><a href="#dfn-conforming-ecmascript-implementation">conforming ECMAScript implementation</a><span>, in §Unnumbered section</span>
<li><a href="#dfn-conforming-implementation">conforming implementation</a><span>, in §Unnumbered section</span>
<li><a href="#dfn-conforming-set-of-idl-fragments">conforming set of IDL fragments</a><span>, in §Unnumbered section</span>
<li><a href="#dfn-consequential-interfaces">consequential interfaces</a><span>, in §2.9</span>
<li><a href="#dfn-constant">constant</a><span>, in §2.2.1</span>
<li><a href="#constrainterror">ConstraintError</a><span>, in §2.5.1</span>
<li><a href="#Constructor">Constructor</a><span>, in §3.3.1</span>
<li><a href="#dfn-convert-serialized-value-to-ecmascript-value">convert a serialized value to an ECMAScript value</a><span>, in §3.6.7.2</span>
<li><a href="#dfn-convert-idl-to-ecmascript-value">converted to an ECMAScript value</a><span>, in §3.2</span>
<li><a href="#dfn-convert-ecmascript-to-idl-value">converted to an IDL value</a><span>, in §3.2</span>
<li><a href="#dfn-convert-to-serialized-value">converted to a serialized value</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-convert-idl-to-ecmascript-value">converted to ECMAScript values</a><span>, in §3.2</span>
<li><a href="#dfn-convert-ecmascript-to-idl-value">converted to IDL values</a><span>, in §3.2</span>
<li><a href="#dfn-convert-to-serialized-value">converted to serialized values</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-obtain-unicode">convert to a sequence of Unicode scalar values</a><span>, in §2.11.15</span>
<li><a href="#dfn-create-frozen-array">create a frozen array</a><span>, in §3.2.33</span>
<li><a href="#dfn-create-exception">created</a><span>, in §2.5</span>
<li><a href="#create-frozen-array-from-iterable">Creating a frozen array from an iterable</a><span>, in §3.2.33</span>
<li><a href="#dfn-create-operation-function">creating an operation function</a><span>, in §3.6.7</span>
<li><a href="#create-sequence-from-iterable">Creating a sequence from an iterable</a><span>, in §3.2.25</span>
<li><a href="#dfn-current-global-environment">current global environment</a><span>, in §3.14</span>
<li><a href="#dom-domexception-data_clone_err">DATA_CLONE_ERR</a><span>, in §2.5.1</span>
<li><a href="#datacloneerror">DataCloneError</a><span>, in §2.5.1</span>
<li><a href="#dataerror">DataError</a><span>, in §2.5.1</span>
<li><a href="#idl-DataView">DataView</a><span>, in §2.11.31</span>
<li><a href="#dfn-default-iterator-object">default iterator object</a><span>, in §3.6.9.4</span>
<li><a href="#dfn-default-unforgeable-valueOf-function">default unforgeable valueOf function</a><span>, in §3.8</span>
<li>
default value
<ul>
<li><a href="#dfn-optional-argument-default-value">dfn for optional argument</a><span>, in §2.2.3</span>
<li><a href="#dfn-dictionary-member-default-value">dfn for dictionary member</a><span>, in §2.4</span>
</ul>
<li><a href="#dfn-definition">definitions</a><span>, in §2</span>
<li><a href="#dfn-delete-an-existing-named-property">delete an existing named property</a><span>, in §2.2.4.5</span>
<li><a href="#dfn-deleter">deleter</a><span>, in §2.2.4</span>
<li><a href="#dfn-detach">detach</a><span>, in §2.11.31</span>
<li><a href="#dfn-determine-the-value-of-a-named-property">determine the value of a named property</a><span>, in §2.2.4.5</span>
<li><a href="#dfn-determine-the-value-of-an-indexed-property">determine the value of an indexed property</a><span>, in §2.2.4.4</span>
<li><a href="#dfn-dictionary">dictionary</a><span>, in §2.4</span>
<li><a href="#dfn-dictionary-member">dictionary members</a><span>, in §2.4</span>
<li><a href="#idl-dictionary">Dictionary types</a><span>, in §2.11.19</span>
<li><a href="#dfn-distinguishable">distinguishable</a><span>, in §2.2.6</span>
<li><a href="#dfn-distinguishing-argument-index">distinguishing argument index</a><span>, in §2.2.6</span>
<li><a href="#dfn-DOMException">DOMException</a><span>, in §2.5</span>
<li><a href="#dfn-DOMException-constructor-object">DOMException constructor object</a><span>, in §3.12</span>
<li><a href="#dfn-DOMException-prototype-object">DOMException prototype object</a><span>, in §3.12.1</span>
<li><a href="#idl-DOMString">DOMString</a><span>, in §2.11.14</span>
<li><a href="#DOMTimeStamp">DOMTimeStamp</a><span>, in §4.2</span>
<li><a href="#idl-double">double</a><span>, in §2.11.12</span>
<li><a href="#dfn-effective-overload-set">effective overload set</a><span>, in §2.2.6</span>
<li><a href="#encodingerror">EncodingError</a><span>, in §2.5.1</span>
<li><a href="#EnforceRange">EnforceRange</a><span>, in §3.3.2</span>
<li><a href="#dfn-enumeration">enumeration</a><span>, in §2.6</span>
<li><a href="#idl-enumeration">Enumeration types</a><span>, in §2.11.20</span>
<li><a href="#dfn-enumeration-value">enumeration value</a><span>, in §2.6</span>
<li>
Error
<ul>
<li><a href="#exceptiondef-error">(exception)</a><span>, in §2.5</span>
<li><a href="#idl-Error">(interface)</a><span>, in §2.11.28</span>
</ul>
<li><a href="#dfn-exception-error-name">error name</a><span>, in §2.5</span>
<li><a href="#dfn-error-names-table">error names table</a><span>, in §2.5.1</span>
<li><a href="#ecmascript-throw">es throw</a><span>, in §3</span>
<li><a href="#exceptiondef-evalerror">EvalError</a><span>, in §2.5</span>
<li><a href="#dfn-example-term">example term</a><span>, in §Unnumbered section</span>
<li><a href="#dfn-exception">exception</a><span>, in §2.5</span>
<li><a href="#es-exception-objects">Exception objects</a><span>, in §3.12.2</span>
<li><a href="#dfn-exception-type">exception types</a><span>, in §2.11</span>
<li><a href="#Exposed">Exposed</a><span>, in §3.3.3</span>
<li><a href="#dfn-exposed">exposed</a><span>, in §3.3.4</span>
<li><a href="#dfn-expose">exposes</a><span>, in §3.1</span>
<li><a href="#dfn-exposure-set">exposure set</a><span>, in §3.3.4</span>
<li><a href="#dfn-extended-attribute">extended attribute</a><span>, in §2.12</span>
<li><a href="#dfn-flattened-union-member-types">flattened member types</a><span>, in §2.11.27</span>
<li><a href="#idl-float">float</a><span>, in §2.11.10</span>
<li><a href="#idl-Float32Array">Float32Array</a><span>, in §2.11.31</span>
<li><a href="#idl-Float64Array">Float64Array</a><span>, in §2.11.31</span>
<li><a href="#dfn-forwards-to-the-internal-map-object">forwards to the internal map object</a><span>, in §3.6.10</span>
<li><a href="#dfn-forwards-to-the-internal-set-object">forwards to the internal set object</a><span>, in §3.6.11</span>
<li><a href="#idl-frozen-array">FrozenArray</a><span>, in §2.11.31</span>
<li><a href="#idl-frozen-array">FrozenArray<T></a><span>, in §2.11.31</span>
<li><a href="#dfn-frozen-array-type">frozen array type</a><span>, in §2.11.32</span>
<li><a href="#Function">Function</a><span>, in §4.3</span>
<li><a href="#dfn-function-object">function object</a><span>, in §3</span>
<li><a href="#dfn-get-buffer-source-copy">get a copy of the buffer source</a><span>, in §2.11.31</span>
<li><a href="#dfn-get-buffer-source-reference">get a reference to the buffer source</a><span>, in §2.11.31</span>
<li><a href="#get-a-user-objects-attribute-value">get a user object’s attribute value</a><span>, in §3.9</span>
<li><a href="#dfn-getter">getter</a><span>, in §2.2.4</span>
<li><a href="#Global">Global</a><span>, in §3.3.4</span>
<li><a href="#dfn-global-name">global names</a><span>, in §3.3.5</span>
<li><a href="#dom-domexception-hierarchy_request_err">HIERARCHY_REQUEST_ERR</a><span>, in §2.5.1</span>
<li><a href="#hierarchyrequesterror">HierarchyRequestError</a><span>, in §2.5.1</span>
<li><a href="#dfn-identifier">identifier</a><span>, in §2.1</span>
<li><a href="#dfn-idl-fragment">IDL fragment</a><span>, in §2</span>
<li><a href="#dfn-implements-statement">implements statement</a><span>, in §2.9</span>
<li><a href="#dfn-includes-a-nullable-type">includes a nullable type</a><span>, in §2.11.27</span>
<li><a href="#idl-indexed-properties">Indexed properties</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-indexed-property-getter">indexed property getter</a><span>, in §2.2.4</span>
<li><a href="#dfn-indexed-property-setter">indexed property setter</a><span>, in §2.2.4</span>
<li><a href="#dom-domexception-index_size_err">INDEX_SIZE_ERR</a><span>, in §2.5.1</span>
<li><a href="#indexsizeerror">IndexSizeError</a><span>, in §2.5.1</span>
<li>
inherit
<ul>
<li><a href="#dfn-inherit">dfn for interface</a><span>, in §2.2</span>
<li><a href="#dfn-inherit-dictionary">dfn for dictionary</a><span>, in §2.4</span>
</ul>
<li><a href="#dfn-inherited-dictionaries">inherited dictionaries</a><span>, in §2.4</span>
<li><a href="#dfn-inherited-interfaces">inherited interfaces</a><span>, in §2.2</span>
<li><a href="#dfn-inherit-getter">inherit its getter</a><span>, in §2.2.2</span>
<li><a href="#dfn-initial-object">initial objects</a><span>, in §3.1</span>
<li><a href="#dfn-inner-type">inner type</a><span>, in §2.11.23</span>
<li><a href="#idl-Int16Array">Int16Array</a><span>, in §2.11.31</span>
<li><a href="#idl-Int32Array">Int32Array</a><span>, in §2.11.31</span>
<li><a href="#idl-Int8Array">Int8Array</a><span>, in §2.11.31</span>
<li><a href="#dfn-integer-type">integer types</a><span>, in §2.11</span>
<li><a href="#dfn-interface">interface</a><span>, in §2.2</span>
<li><a href="#dfn-interface-member">interface member</a><span>, in §2.2</span>
<li><a href="#dfn-interface-object">interface object</a><span>, in §3.6</span>
<li><a href="#dfn-interface-prototype-object">interface prototype object</a><span>, in §3.6.1</span>
<li><a href="#idl-interface">Interface types</a><span>, in §2.11.18</span>
<li><a href="#dom-domexception-inuse_attribute_err">INUSE_ATTRIBUTE_ERR</a><span>, in §2.5.1</span>
<li><a href="#inuseattributeerror">InUseAttributeError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-invalid_access_err">INVALID_ACCESS_ERR</a><span>, in §2.5.1</span>
<li><a href="#invalidaccesserror">InvalidAccessError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-invalid_character_err">INVALID_CHARACTER_ERR</a><span>, in §2.5.1</span>
<li><a href="#invalidcharactererror">InvalidCharacterError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-invalid_modification_err">INVALID_MODIFICATION_ERR</a><span>, in §2.5.1</span>
<li><a href="#invalidmodificationerror">InvalidModificationError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-invalid_node_type_err">INVALID_NODE_TYPE_ERR</a><span>, in §2.5.1</span>
<li><a href="#invalidnodetypeerror">InvalidNodeTypeError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-invalid_state_err">INVALID_STATE_ERR</a><span>, in §2.5.1</span>
<li><a href="#invalidstateerror">InvalidStateError</a><span>, in §2.5.1</span>
<li><a href="#invoke-a-callback-function">invoke</a><span>, in §3.10</span>
<li><a href="#invoke-indexed-setter">invoke the indexed property setter</a><span>, in §3.8.4</span>
<li><a href="#invoke-named-setter">invoke the named property setter</a><span>, in §3.8.5</span>
<li><a href="#dfn-iterable">iterable</a><span>, in §2.2.7</span>
<li><a href="#dfn-iterable-declaration">iterable declaration</a><span>, in §2.2.7</span>
<li><a href="#dfn-iterator-prototype-object">iterator prototype object</a><span>, in §3.6.9.5</span>
<li><a href="#dfn-legacy-caller">legacy</a><span>, in §2.2.4</span>
<li><a href="#LegacyArrayClass">LegacyArrayClass</a><span>, in §3.3.5</span>
<li><a href="#idl-legacy-callers">Legacy callers</a><span>, in §2.2.4</span>
<li><a href="#LegacyUnenumerableNamedProperties">LegacyUnenumerableNamedProperties</a><span>, in §3.3.6</span>
<li><a href="#LenientSetter">LenientSetter</a><span>, in §3.3.7</span>
<li><a href="#LenientThis">LenientThis</a><span>, in §3.3.8</span>
<li><a href="#idl-long">long</a><span>, in §2.11.6</span>
<li><a href="#idl-long-long">long long</a><span>, in §2.11.8</span>
<li><a href="#dfn-map-entries">map entries</a><span>, in §2.2.8</span>
<li><a href="#dfn-maplike">maplike</a><span>, in §2.2.8</span>
<li><a href="#dfn-maplike-declaration">maplike declaration</a><span>, in §2.2.8</span>
<li><a href="#opendictionary-mappings">mappings</a><span>, in §2.11.25</span>
<li><a href="#dfn-map-size-getter">map size getter</a><span>, in §3.6.10.1</span>
<li><a href="#dfn-union-member-type">member types</a><span>, in §2.11.27</span>
<li><a href="#dfn-exception-message">message</a><span>, in §2.5</span>
<li><a href="#dfn-named-constructor">named constructor</a><span>, in §3.6</span>
<li><a href="#NamedConstructor">NamedConstructor</a><span>, in §3.3.9</span>
<li><a href="#dfn-named-definition">named definition</a><span>, in §2.1</span>
<li><a href="#idl-named-properties">Named properties</a><span>, in §2.2.4.4</span>
<li><a href="#dfn-named-properties-object">named properties object</a><span>, in §3.6.4</span>
<li><a href="#dfn-named-property-deleter">named property deleter</a><span>, in §2.2.4</span>
<li><a href="#dfn-named-property-getter">named property getter</a><span>, in §2.2.4</span>
<li><a href="#dfn-named-property-setter">named property setter</a><span>, in §2.2.4</span>
<li><a href="#dfn-named-property-visibility">named property visibility algorithm</a><span>, in §3.8.1</span>
<li><a href="#dfn-namespace">namespace</a><span>, in §2.3</span>
<li><a href="#dom-domexception-namespace_err">NAMESPACE_ERR</a><span>, in §2.5.1</span>
<li><a href="#namespaceerror">NamespaceError</a><span>, in §2.5.1</span>
<li><a href="#dfn-namespace-member">namespace member</a><span>, in §2.3</span>
<li><a href="#dfn-namespace-object">namespace object</a><span>, in §3.11</span>
<li><a href="#dom-domexception-network_err">NETWORK_ERR</a><span>, in §2.5.1</span>
<li><a href="#networkerror">NetworkError</a><span>, in §2.5.1</span>
<li><a href="#NewObject">NewObject</a><span>, in §3.3.10</span>
<li><a href="#NoInterfaceObject">NoInterfaceObject</a><span>, in §3.3.11</span>
<li><a href="#dom-domexception-no_modification_allowed_err">NO_MODIFICATION_ALLOWED_ERR</a><span>, in §2.5.1</span>
<li><a href="#nomodificationallowederror">NoModificationAllowedError</a><span>, in §2.5.1</span>
<li><a href="#notallowederror">NotAllowedError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-not_found_err">NOT_FOUND_ERR</a><span>, in §2.5.1</span>
<li><a href="#notfounderror">NotFoundError</a><span>, in §2.5.1</span>
<li><a href="#notreadableerror">NotReadableError</a><span>, in §2.5.1</span>
<li><a href="#dom-domexception-not_supported_err">NOT_SUPPORTED_ERR</a><span>, in §2.5.1</span>
<li><a href="#notsupportederror">NotSupportedError</a><span>, in §2.5.1</span>
<li><a href="#dfn-nullable-type">nullable type</a><span>, in §2.11.23</span>
<li><a href="#dfn-number-of-nullable-member-types">number of nullable member types</a><span>, in §2.11.27</span>
<li><a href="#dfn-numeric-type">numeric types</a><span>, in §2.11</span>
<li><a href="#idl-object">object</a><span>, in §2.11.17</span>
<li><a href="#dfn-object-type">object types</a><span>, in §2.11</span>
<li><a href="#dfn-obtain-unicode">obtain Unicode</a><span>, in §2.11.15</span>
<li><a href="#idl-octet">octet</a><span>, in §2.11.3</span>
<li><a href="#idl-open-dictionary">OpenDictionary</a><span>, in §2.11.24</span>
<li><a href="#open-dictionary-type">open dictionary type</a><span>, in §2.11.25</span>
<li><a href="#dfn-operation">operation</a><span>, in §2.2.3</span>
<li><a href="#operationerror">OperationError</a><span>, in §2.5.1</span>
<li><a href="#dfn-optional-argument">optional argument</a><span>, in §2.2.3</span>
<li><a href="#dfn-optionality-value">optionality values</a><span>, in §2.2.6</span>
<li><a href="#dfn-overloaded">overloaded</a><span>, in §2.2.6</span>
<li><a href="#dfn-overload-resolution-algorithm">overload resolution algorithm</a><span>, in §3.5</span>
<li><a href="#OverrideBuiltins">OverrideBuiltins</a><span>, in §3.3.12</span>
<li><a href="#dfn-pair-iterator">pair iterator</a><span>, in §2.2.7</span>
<li><a href="#dfn-partial-dictionary">partial dictionary</a><span>, in §2.4</span>
<li><a href="#dfn-partial-interface">partial interface</a><span>, in §2.2</span>
<li><a href="#dfn-partial-namespace">partial namespace</a><span>, in §2.3</span>
<li><a href="#dfn-perform-a-security-check">perform a security check</a><span>, in §3.4</span>
<li><a href="#dfn-platform-object">platform object</a><span>, in §2.10</span>
<li><a href="#dfn-present">present</a><span>, in §2.4</span>
<li><a href="#Global">PrimaryGlobal</a><span>, in §3.3.4</span>
<li><a href="#dfn-primary-global-interface">primary global interface</a><span>, in §3.3.5</span>
<li><a href="#dfn-primary-interface">primary interface</a><span>, in §3.8</span>
<li><a href="#dfn-primitive-type">primitive types</a><span>, in §2.11</span>
<li><a href="#dfn-processing-equivalence">processing equivalence</a><span>, in §Unnumbered section</span>
<li><a href="#idl-promise">Promise</a><span>, in §2.11.25</span>
<li><a href="#idl-promise">Promise<T></a><span>, in §2.11.25</span>
<li><a href="#dfn-promise-type">promise type</a><span>, in §2.11.26</span>
<li><a href="#PutForwards">PutForwards</a><span>, in §3.3.13</span>
<li><a href="#dom-domexception-quota_exceeded_err">QUOTA_EXCEEDED_ERR</a><span>, in §2.5.1</span>
<li><a href="#quotaexceedederror">QuotaExceededError</a><span>, in §2.5.1</span>
<li><a href="#exceptiondef-rangeerror">RangeError</a><span>, in §2.5</span>
<li><a href="#dfn-read-only">read only</a><span>, in §2.2.2</span>
<li><a href="#readonlyerror">ReadOnlyError</a><span>, in §2.5.1</span>
<li><a href="#exceptiondef-referenceerror">ReferenceError</a><span>, in §2.5</span>
<li><a href="#idl-RegExp">RegExp</a><span>, in §2.11.27</span>
<li><a href="#dfn-regular-attribute">regular attribute</a><span>, in §2.2.2</span>
<li><a href="#dfn-regular-operation">regular operation</a><span>, in §2.2.3</span>
<li><a href="#Replaceable">Replaceable</a><span>, in §3.3.14</span>
<li><a href="#required-dictionary-member">required dictionary member</a><span>, in §2.4</span>
<li><a href="#dfn-reserved-identifier">reserved identifiers</a><span>, in §2.1</span>
<li><a href="#dfn-return-type">return type</a><span>, in §2.2.3</span>
<li><a href="#SameObject">SameObject</a><span>, in §3.3.15</span>
<li><a href="#SecureContext">SecureContext</a><span>, in §3.3.16</span>
<li><a href="#dom-domexception-security_err">SECURITY_ERR</a><span>, in §2.5.1</span>
<li><a href="#securityerror">SecurityError</a><span>, in §2.5.1</span>
<li><a href="#idl-sequence">sequence</a><span>, in §2.11.23</span>
<li><a href="#idl-sequence">sequence<T></a><span>, in §2.11.23</span>
<li><a href="#sequence-type">sequence type</a><span>, in §2.11.24</span>
<li><a href="#dfn-serializable-type">serializable type</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-serialization-behavior">serialization behavior</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-serialization-pattern">serialization pattern</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-serialized-value">serialized value</a><span>, in §2.2.4.3</span>
<li><a href="#dfn-serializer">serializer</a><span>, in §2.2.4</span>
<li><a href="#set-a-user-objects-attribute-value">set a user object’s attribute value</a><span>, in §3.9</span>
<li><a href="#dfn-set-entries">set entries</a><span>, in §2.2.9</span>
<li><a href="#dfn-setlike">setlike</a><span>, in §2.2.9</span>
<li><a href="#dfn-setlike-declaration">setlike declaration</a><span>, in §2.2.9</span>
<li><a href="#dfn-set-size-getter">set size getter</a><span>, in §3.6.11.1</span>
<li><a href="#dfn-setter">setter</a><span>, in §2.2.4</span>
<li><a href="#dfn-set-the-value-of-a-new-indexed-property">set the value of a new indexed property</a><span>, in §2.2.4.4</span>
<li><a href="#dfn-set-the-value-of-a-new-named-property">set the value of a new named property</a><span>, in §2.2.4.5</span>
<li><a href="#dfn-set-the-value-of-an-existing-indexed-property">set the value of an existing indexed property</a><span>, in §2.2.4.4</span>
<li><a href="#dfn-set-the-value-of-an-existing-named-property">set the value of an existing named property</a><span>, in §2.2.4.5</span>
<li><a href="#idl-short">short</a><span>, in §2.11.4</span>
<li><a href="#dfn-simple-exception">simple exception</a><span>, in §2.5</span>
<li><a href="#dfn-single-operation-callback-interface">single operation callback interface</a><span>, in §3.9</span>
<li><a href="#dfn-special-keyword">special keywords</a><span>, in §2.2.4</span>
<li><a href="#dfn-special-operation">special operation</a><span>, in §2.2.4</span>
<li><a href="#dfn-specific-type">specific type</a><span>, in §2.11.1</span>
<li><a href="#dfn-static-attribute">Static attributes</a><span>, in §2.2.5</span>
<li><a href="#dfn-static-operation">static operations</a><span>, in §2.2.5</span>
<li><a href="#dfn-stringification-behavior">stringification behavior</a><span>, in §2.2.4.2</span>
<li><a href="#dfn-stringifier">stringifier</a><span>, in §2.2.4</span>
<li><a href="#dfn-string-type">string types</a><span>, in §2.11</span>
<li><a href="#dfn-supplemental-interface">supplemental interface</a><span>, in §2.9</span>
<li><a href="#dfn-supported-property-indices">supported property indices</a><span>, in §2.2.4.4</span>
<li><a href="#dfn-supported-property-names">supported property names</a><span>, in §2.2.4.5</span>
<li><a href="#dfn-support-indexed-properties">support indexed properties</a><span>, in §2.2.4.4</span>
<li><a href="#dfn-support-named-properties">support named properties</a><span>, in §2.2.4.5</span>
<li><a href="#dom-domexception-syntax_err">SYNTAX_ERR</a><span>, in §2.5.1</span>
<li><a href="#syntaxerror">SyntaxError</a><span>, in §2.5.1</span>
<li><a href="#dfn-xattr-named-argument-list">takes a named argument list</a><span>, in §2.12</span>
<li><a href="#dfn-xattr-argument-list">takes an argument list</a><span>, in §2.12</span>
<li><a href="#dfn-xattr-identifier">takes an identifier</a><span>, in §2.12</span>
<li><a href="#dfn-xattr-identifier-list">takes an identifier list</a><span>, in §2.12</span>
<li><a href="#dfn-xattr-no-arguments">takes no arguments</a><span>, in §2.12</span>
<li><a href="#getownproperty-guts">The PlatformObjectGetOwnProperty abstract operation</a><span>, in §3.8.1</span>
<li><a href="#dfn-throw">throw</a><span>, in §2.5</span>
<li><a href="#dfn-throw">thrown</a><span>, in §2.5</span>
<li><a href="#dom-domexception-timeout_err">TIMEOUT_ERR</a><span>, in §2.5.1</span>
<li><a href="#timeouterror">TimeoutError</a><span>, in §2.5.1</span>
<li><a href="#transactioninactiveerror">TransactionInactiveError</a><span>, in §2.5.1</span>
<li><a href="#TreatNonObjectAsNull">TreatNonObjectAsNull</a><span>, in §3.3.17</span>
<li><a href="#TreatNullAs">TreatNullAs</a><span>, in §3.3.18</span>
<li><a href="#dfn-typed-array-type">typed array types</a><span>, in §2.11</span>
<li><a href="#dfn-typedef">typedef</a><span>, in §2.8</span>
<li><a href="#exceptiondef-typeerror">TypeError</a><span>, in §2.5</span>
<li><a href="#dfn-type-name">type name</a><span>, in §2.11</span>
<li><a href="#idl-Uint16Array">Uint16Array</a><span>, in §2.11.31</span>
<li><a href="#idl-Uint32Array">Uint32Array</a><span>, in §2.11.31</span>
<li><a href="#idl-Uint8Array">Uint8Array</a><span>, in §2.11.31</span>
<li><a href="#idl-Uint8ClampedArray">Uint8ClampedArray</a><span>, in §2.11.31</span>
<li><a href="#dfn-unforgeable-on-an-interface">unforgeable</a><span>, in §3.3.20</span>
<li><a href="#Unforgeable">Unforgeable</a><span>, in §3.3.19</span>
<li><a href="#dfn-unforgeable-property-name">unforgeable property name</a><span>, in §3.8.1</span>
<li><a href="#dfn-union-type">union type</a><span>, in §2.11.27</span>
<li><a href="#unknownerror">UnknownError</a><span>, in §2.5.1</span>
<li><a href="#idl-unrestricted-double">unrestricted double</a><span>, in §2.11.13</span>
<li><a href="#idl-unrestricted-float">unrestricted float</a><span>, in §2.11.11</span>
<li><a href="#Unscopable">Unscopable</a><span>, in §3.3.20</span>
<li><a href="#idl-unsigned-long">unsigned long</a><span>, in §2.11.7</span>
<li><a href="#idl-unsigned-long-long">unsigned long long</a><span>, in §2.11.9</span>
<li><a href="#idl-unsigned-short">unsigned short</a><span>, in §2.11.5</span>
<li><a href="#dfn-perform-steps-once-promise-is-settled">upon settling</a><span>, in §3.2.27</span>
<li><a href="#exceptiondef-urierror">URIError</a><span>, in §2.5</span>
<li><a href="#dom-domexception-url_mismatch_err">URL_MISMATCH_ERR</a><span>, in §2.5.1</span>
<li><a href="#urlmismatcherror">URLMismatchError</a><span>, in §2.5.1</span>
<li><a href="#dfn-user-object">user object</a><span>, in §2.10</span>
<li><a href="#idl-USVString">USVString</a><span>, in §2.11.16</span>
<li><a href="#dfn-value-iterator">value iterator</a><span>, in §2.2.7</span>
<li><a href="#dfn-value-pairs-to-iterate-over">value pairs to iterate over</a><span>, in §2.2.7</span>
<li><a href="#dfn-variadic">variadic</a><span>, in §2.2.3</span>
<li><a href="#versionerror">VersionError</a><span>, in §2.5.1</span>
<li><a href="#idl-void">void</a><span>, in §2.2.3</span>
<li><a href="#VoidFunction">VoidFunction</a><span>, in §4.4</span>
<li><a href="#dom-domexception-wrong_document_err">WRONG_DOCUMENT_ERR</a><span>, in §2.5.1</span>
<li><a href="#wrongdocumenterror">WrongDocumentError</a><span>, in §2.5.1</span>
</ul>
<h3 class="no-num no-ref heading settled" id="index-defined-elsewhere"><span class="content">Terms defined by reference</span><a class="self-link" href="#index-defined-elsewhere"></a></h3>
<ul class="index">
<li>
<a data-link-type="biblio">[ECMA-262]</a> defines the following terms:
<ul>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">!</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%arrayproto_values%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%arrayprototype%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%error%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%errorprototype%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-properties-of-the-function-prototype-object">%functionprototype%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%iteratorprototype%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-properties-of-the-object-prototype-object">%objectprototype%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-intrinsic-objects">%objproto_tostring%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-promise-constructor">%promise%</a>
<li><a href="https://tc39.github.io/ecma262/#sec-built-in-function-objects-call-thisargument-argumentslist">9.3.1</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">?</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@iterator</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@tostringtag</a>
<li><a href="https://tc39.github.io/ecma262/#sec-well-known-symbols">@@unscopables</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">abs</a>
<li><a href="https://tc39.github.io/ecma262/#sec-array-iterator-objects">array iterator objects</a>
<li><a href="https://tc39.github.io/ecma262/#sec-properties-of-the-array-prototype-object">array methods</a>
<li><a href="https://tc39.github.io/ecma262/#sec-arraycreate">arraycreate</a>
<li><a href="https://tc39.github.io/ecma262/#sec-call">call</a>
<li><a href="https://tc39.github.io/ecma262/#sec-iscallable">callable</a>
<li><a href="https://tc39.github.io/ecma262/#sec-completion-record-specification-type">completion</a>
<li><a href="https://tc39.github.io/ecma262/#sec-construct">construct</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">conventions of the ecmascript specification</a>
<li><a href="https://tc39.github.io/ecma262/#sec-createbuiltinfunction">createbuiltinfunction</a>
<li><a href="https://tc39.github.io/ecma262/#sec-createdataproperty">createdataproperty</a>
<li><a href="https://tc39.github.io/ecma262/#sec-createiterresultobject">createiterresultobject</a>
<li><a href="https://tc39.github.io/ecma262/#sec-createmapiterator">createmapiterator</a>
<li><a href="https://tc39.github.io/ecma262/#sec-createsetiterator">createsetiterator</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-set-p-v-receiver">default [[set]] internal method</a>
<li><a href="https://tc39.github.io/ecma262/#sec-definepropertyorthrow">definepropertyorthrow</a>
<li><a href="https://tc39.github.io/ecma262/#sec-detacharraybuffer">detacharraybuffer</a>
<li><a href="https://tc39.github.io/ecma262/#sec-function-@@create">ecma-262 section 19.2.2.3</a>
<li><a href="https://tc39.github.io/ecma262/#sec-function.prototype-@@hasinstance">ecma-262 section 19.2.3.8</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">ecma-262 section 5.2</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-get-p-receiver">ecma-262 section 9.1.8</a>
<li><a href="https://tc39.github.io/ecma262/#sec-error-objects">ecmascript error objects</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type">element</a>
<li><a href="https://tc39.github.io/ecma262/#sec-property-attributes">enumerable</a>
<li><a href="https://tc39.github.io/ecma262/#sec-enumerableownproperties">enumerableownproperties</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">equally close values</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">floor</a>
<li><a href="https://tc39.github.io/ecma262/#sec-get-o-p">get</a>
<li><a href="https://tc39.github.io/ecma262/#sec-getiterator">getiterator</a>
<li><a href="https://tc39.github.io/ecma262/#sec-getmethod">getmethod</a>
<li><a href="https://tc39.github.io/ecma262/#sec-hasownproperty">hasownproperty</a>
<li><a href="https://tc39.github.io/ecma262/#sec-immutable-prototype-exotic-objects">immutable prototype exotic object</a>
<li><a href="https://tc39.github.io/ecma262/#sec-object-internal-methods-and-internal-slots">internal slot</a>
<li><a href="https://tc39.github.io/ecma262/#sec-isaccessordescriptor">isaccessordescriptor</a>
<li><a href="https://tc39.github.io/ecma262/#sec-iscallable">iscallable</a>
<li><a href="https://tc39.github.io/ecma262/#sec-isconstructor">isconstructor</a>
<li><a href="https://tc39.github.io/ecma262/#sec-isdatadescriptor">isdatadescriptor</a>
<li><a href="https://tc39.github.io/ecma262/#sec-isdetachedbuffer">isdetachedbuffer</a>
<li><a href="https://tc39.github.io/ecma262/#sec-iteratorstep">iteratorstep</a>
<li><a href="https://tc39.github.io/ecma262/#sec-iteratorvalue">iteratorvalue</a>
<li><a href="https://tc39.github.io/ecma262/#sec-list-and-record-specification-type">list</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">modulo</a>
<li><a href="https://tc39.github.io/ecma262/#sec-normalcompletion">normalcompletion</a>
<li><a href="https://tc39.github.io/ecma262/#sec-literals-numeric-literals">numericliteral</a>
<li><a href="https://tc39.github.io/ecma262/#sec-objectcreate">objectcreate</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ordinarydefineownproperty">ordinarydefineownproperty</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ordinarygetownproperty">ordinarygetownproperty</a>
<li><a href="https://tc39.github.io/ecma262/#sec-own-property">own property</a>
<li><a href="https://tc39.github.io/ecma262/#sec-property-descriptor-specification-type">property descriptor</a>
<li><a href="https://tc39.github.io/ecma262/#sec-code-realms">realm</a>
<li><a href="https://tc39.github.io/ecma262/#sec-returnifabrupt">returnifabrupt</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots">sections 9.1</a>
<li><a href="https://tc39.github.io/ecma262/#sec-set-o-p-v-throw">set</a>
<li><a href="https://tc39.github.io/ecma262/#sec-setfunctionname">setfunctionname</a>
<li><a href="https://tc39.github.io/ecma262/#sec-setintegritylevel">setintegritylevel</a>
<li><a href="https://tc39.github.io/ecma262/#sec-algorithm-conventions">sign</a>
<li><a href="https://tc39.github.io/ecma262/#sec-toboolean">toboolean</a>
<li><a href="https://tc39.github.io/ecma262/#sec-toint32">toint32</a>
<li><a href="https://tc39.github.io/ecma262/#sec-tonumber">tonumber</a>
<li><a href="https://tc39.github.io/ecma262/#sec-toobject">toobject</a>
<li><a href="https://tc39.github.io/ecma262/#sec-tostring">tostring</a>
<li><a href="https://tc39.github.io/ecma262/#sec-touint16">touint16</a>
<li><a href="https://tc39.github.io/ecma262/#sec-touint32">touint32</a>
<li><a href="https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values">type</a>
<li><a href="https://tc39.github.io/ecma262/#sec-typedarray-objects">typed arrays</a>
</ul>
<li>
<a data-link-type="biblio">[HTML]</a> defines the following terms:
<ul>
<li><a href="https://html.spec.whatwg.org/multipage/browsers.html#window">Window</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-a-callback">clean up after running a callback</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#clean-up-after-running-script">clean up after running script</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-attributes">event handler idl attributes</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-global">global object</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#incumbent-settings-object">incumbent settings object</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-a-callback">prepare to run a callback</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#prepare-to-run-script">prepare to run script</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-relevant-realm">relevant realm</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#relevant-settings-object">relevant settings object</a>
<li><a href="https://html.spec.whatwg.org/multipage/webappapis.html#concept-realm-settings-object">settings object</a>
</ul>
<li>
<a data-link-type="biblio">[secure-contexts]</a> defines the following terms:
<ul>
<li><a href="https://w3c.github.io/webappsec-secure-contexts/#secure-context">secure context</a>
</ul>
<li>
<a data-link-type="biblio">[UNICODE]</a> defines the following terms:
<ul>
<li><a href="http://www.unicode.org/glossary/#unicode_scalar_value">unicode scalar value</a>
</ul>
</ul>
<h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
<h3 class="no-num no-ref heading settled" id="normative"><span class="content">Normative References</span><a class="self-link" href="#normative"></a></h3>
<dl>
<dt id="biblio-ecma-262">[ECMA-262]
<dd><a href="https://tc39.github.io/ecma262/">ECMAScript Language Specification</a>. URL: <a href="https://tc39.github.io/ecma262/">https://tc39.github.io/ecma262/</a>
<dt id="biblio-html">[HTML]
<dd>Ian Hickson. <a href="https://html.spec.whatwg.org/multipage/">HTML Standard</a>. Living Standard. URL: <a href="https://html.spec.whatwg.org/multipage/">https://html.spec.whatwg.org/multipage/</a>
<dt id="biblio-ieee-754">[IEEE-754]
<dd><a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985)</a>. 29 August 2008. URL: <a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">http://ieeexplore.ieee.org/servlet/opac?punumber=4610933</a>
<dt id="biblio-perlre">[PERLRE]
<dd><a href="http://search.cpan.org/dist/perl/pod/perlre.pod">Perl regular expressions (Perl 5.8.8)</a>. February 2006. URL: <a href="http://search.cpan.org/dist/perl/pod/perlre.pod">http://search.cpan.org/dist/perl/pod/perlre.pod</a>
<dt id="biblio-rfc2119">[RFC2119]
<dd>S. Bradner. <a href="https://tools.ietf.org/html/rfc2119">Key words for use in RFCs to Indicate Requirement Levels</a>. March 1997. Best Current Practice. URL: <a href="https://tools.ietf.org/html/rfc2119">https://tools.ietf.org/html/rfc2119</a>
<dt id="biblio-rfc2781">[RFC2781]
<dd>P. Hoffman; F. Yergeau. <a href="https://tools.ietf.org/html/rfc2781">UTF-16, an encoding of ISO 10646</a>. February 2000. Informational. URL: <a href="https://tools.ietf.org/html/rfc2781">https://tools.ietf.org/html/rfc2781</a>
<dt id="biblio-rfc3629">[RFC3629]
<dd>F. Yergeau. <a href="https://tools.ietf.org/html/rfc3629">UTF-8, a transformation format of ISO 10646</a>. November 2003. Internet Standard. URL: <a href="https://tools.ietf.org/html/rfc3629">https://tools.ietf.org/html/rfc3629</a>
<dt id="biblio-secure-contexts">[SECURE-CONTEXTS]
<dd>Mike West. <a href="https://w3c.github.io/webappsec-secure-contexts/">Secure Contexts</a>. 15 September 2016. CR. URL: <a href="https://w3c.github.io/webappsec-secure-contexts/">https://w3c.github.io/webappsec-secure-contexts/</a>
<dt id="biblio-unicode">[UNICODE]
<dd><a href="http://www.unicode.org/versions/latest/">The Unicode Standard</a>. URL: <a href="http://www.unicode.org/versions/latest/">http://www.unicode.org/versions/latest/</a>
</dl>
<h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
<dl>
<dt id="biblio-dom">[DOM]
<dd>Anne van Kesteren. <a href="https://dom.spec.whatwg.org/">DOM Standard</a>. Living Standard. URL: <a href="https://dom.spec.whatwg.org/">https://dom.spec.whatwg.org/</a>
<dt id="biblio-omgidl">[OMGIDL]
<dd><a href="http://www.omg.org/cgi-bin/doc?formal/08-01-04.pdf">CORBA 3.1 – OMG IDL Syntax and Semantics chapter</a>. January 2008. URL: <a href="http://www.omg.org/cgi-bin/doc?formal/08-01-04.pdf">http://www.omg.org/cgi-bin/doc?formal/08-01-04.pdf</a>
<dt id="biblio-xml-names">[XML-NAMES]
<dd>Tim Bray; et al. <a href="https://www.w3.org/TR/xml-names">Namespaces in XML 1.0 (Third Edition)</a>. 8 December 2009. REC. URL: <a href="https://www.w3.org/TR/xml-names">https://www.w3.org/TR/xml-names</a>
</dl>
<h2 class="no-num no-ref heading settled" id="idl-index"><span class="content">IDL Index</span><a class="self-link" href="#idl-index"></a></h2>
<pre class="idl def"><span class="kt">typedef</span> (<span class="kt">Int8Array</span> <span class="kt">or</span> <span class="kt">Int16Array</span> <span class="kt">or</span> <span class="kt">Int32Array</span> <span class="kt">or</span>
<span class="kt">Uint8Array</span> <span class="kt">or</span> <span class="kt">Uint16Array</span> <span class="kt">or</span> <span class="kt">Uint32Array</span> <span class="kt">or</span> <span class="kt">Uint8ClampedArray</span> <span class="kt">or</span>
<span class="kt">Float32Array</span> <span class="kt">or</span> <span class="kt">Float64Array</span> <span class="kt">or</span> <span class="kt">DataView</span>) <a class="nv idl-code" data-link-type="typedef" href="#ArrayBufferView">ArrayBufferView</a>;
<span class="kt">typedef</span> (<a class="n" data-link-type="idl-name" href="#ArrayBufferView">ArrayBufferView</a> <span class="kt">or</span> <span class="kt">ArrayBuffer</span>) <a class="nv idl-code" data-link-type="typedef" href="#BufferSource">BufferSource</a>;
<span class="kt">typedef</span> <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">long</span> <a class="nv idl-code" data-link-type="typedef" href="#DOMTimeStamp">DOMTimeStamp</a>;
<span class="kt">callback</span> <a class="nv idl-code" data-link-type="callback" href="#Function">Function</a> = <span class="kt">any</span> (<span class="kt">any</span>... <a class="nv" href="#dom-function-arguments">arguments</a>);
<span class="kt">callback</span> <a class="nv idl-code" data-link-type="callback" href="#VoidFunction">VoidFunction</a> = <span class="kt">void</span> ();
</pre>
<aside class="dfn-panel" data-for="dfn-idl-fragment">
<b><a href="#dfn-idl-fragment">#dfn-idl-fragment</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-idl-fragment-1">2. Interface definition language</a> <a href="#ref-for-dfn-idl-fragment-2">(2)</a> <a href="#ref-for-dfn-idl-fragment-3">(3)</a> <a href="#ref-for-dfn-idl-fragment-4">(4)</a>
<li><a href="#ref-for-dfn-idl-fragment-5">2.1. Names</a> <a href="#ref-for-dfn-idl-fragment-6">(2)</a> <a href="#ref-for-dfn-idl-fragment-7">(3)</a> <a href="#ref-for-dfn-idl-fragment-8">(4)</a> <a href="#ref-for-dfn-idl-fragment-9">(5)</a>
<li><a href="#ref-for-dfn-idl-fragment-10">2.2. Interfaces</a> <a href="#ref-for-dfn-idl-fragment-11">(2)</a> <a href="#ref-for-dfn-idl-fragment-12">(3)</a>
<li><a href="#ref-for-dfn-idl-fragment-13">2.2.1. Constants</a>
<li><a href="#ref-for-dfn-idl-fragment-14">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-idl-fragment-15">2.2.3. Operations</a> <a href="#ref-for-dfn-idl-fragment-16">(2)</a> <a href="#ref-for-dfn-idl-fragment-17">(3)</a>
<li><a href="#ref-for-dfn-idl-fragment-18">2.2.4.1. Legacy callers</a>
<li><a href="#ref-for-dfn-idl-fragment-19">2.2.4.2. Stringifiers</a> <a href="#ref-for-dfn-idl-fragment-20">(2)</a>
<li><a href="#ref-for-dfn-idl-fragment-21">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-idl-fragment-22">2.2.4.4. Indexed properties</a>
<li><a href="#ref-for-dfn-idl-fragment-23">2.2.5. Static attributes and operations</a>
<li><a href="#ref-for-dfn-idl-fragment-24">2.3. Namespaces</a>
<li><a href="#ref-for-dfn-idl-fragment-25">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-idl-fragment-26">2.6. Enumerations</a>
<li><a href="#ref-for-dfn-idl-fragment-27">2.7. Callback functions</a>
<li><a href="#ref-for-dfn-idl-fragment-28">2.8. Typedefs</a>
<li><a href="#ref-for-dfn-idl-fragment-29">2.9. Implements statements</a>
<li><a href="#ref-for-dfn-idl-fragment-30">2.10. Objects implementing interfaces</a>
<li><a href="#ref-for-dfn-idl-fragment-31">2.12. Extended attributes</a>
<li><a href="#ref-for-dfn-idl-fragment-32">3.1. ECMAScript environment</a> <a href="#ref-for-dfn-idl-fragment-33">(2)</a>
<li><a href="#ref-for-dfn-idl-fragment-34">3.3.1. [Clamp]</a>
<li><a href="#ref-for-dfn-idl-fragment-35">3.3.3. [EnforceRange]</a>
<li><a href="#ref-for-dfn-idl-fragment-36">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-idl-fragment-37">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-idl-fragment-38">3.3.13. [OverrideBuiltins]</a>
<li><a href="#ref-for-dfn-idl-fragment-39">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-dfn-idl-fragment-40">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-idl-fragment-41">3.3.17. [SecureContext]</a>
<li><a href="#ref-for-dfn-idl-fragment-42">3.3.18. [TreatNonObjectAsNull]</a>
<li><a href="#ref-for-dfn-idl-fragment-43">3.3.19. [TreatNullAs]</a>
<li><a href="#ref-for-dfn-idl-fragment-44">3.3.20. [Unforgeable]</a>
<li><a href="#ref-for-dfn-idl-fragment-45">3.15. Handling exceptions</a>
<li><a href="#ref-for-dfn-idl-fragment-46">5. Extensibility</a>
<li><a href="#ref-for-dfn-idl-fragment-47">6. Referencing this specification</a>
<li><a href="#ref-for-dfn-idl-fragment-48">IDL grammar</a> <a href="#ref-for-dfn-idl-fragment-49">(2)</a>
<li><a href="#ref-for-dfn-idl-fragment-50">Conformance</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-definition">
<b><a href="#dfn-definition">#dfn-definition</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-definition-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-definition-2">2.1. Names</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-definition">
<b><a href="#dfn-named-definition">#dfn-named-definition</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-definition-1">2.1. Names</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-identifier">
<b><a href="#dfn-identifier">#dfn-identifier</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-identifier-1">2.1. Names</a> <a href="#ref-for-dfn-identifier-2">(2)</a> <a href="#ref-for-dfn-identifier-3">(3)</a> <a href="#ref-for-dfn-identifier-4">(4)</a> <a href="#ref-for-dfn-identifier-5">(5)</a> <a href="#ref-for-dfn-identifier-6">(6)</a> <a href="#ref-for-dfn-identifier-7">(7)</a>
<li><a href="#ref-for-dfn-identifier-8">2.2. Interfaces</a> <a href="#ref-for-dfn-identifier-9">(2)</a>
<li><a href="#ref-for-dfn-identifier-10">2.2.1. Constants</a> <a href="#ref-for-dfn-identifier-11">(2)</a>
<li><a href="#ref-for-dfn-identifier-12">2.2.2. Attributes</a> <a href="#ref-for-dfn-identifier-13">(2)</a> <a href="#ref-for-dfn-identifier-14">(3)</a> <a href="#ref-for-dfn-identifier-15">(4)</a>
<li><a href="#ref-for-dfn-identifier-16">2.2.3. Operations</a> <a href="#ref-for-dfn-identifier-17">(2)</a> <a href="#ref-for-dfn-identifier-18">(3)</a> <a href="#ref-for-dfn-identifier-19">(4)</a> <a href="#ref-for-dfn-identifier-20">(5)</a> <a href="#ref-for-dfn-identifier-21">(6)</a>
<li><a href="#ref-for-dfn-identifier-22">2.2.4. Special operations</a>
<li><a href="#ref-for-dfn-identifier-23">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-identifier-24">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-identifier-25">2.2.4.4. Indexed properties</a> <a href="#ref-for-dfn-identifier-26">(2)</a>
<li><a href="#ref-for-dfn-identifier-27">2.2.4.5. Named properties</a> <a href="#ref-for-dfn-identifier-28">(2)</a>
<li><a href="#ref-for-dfn-identifier-29">2.2.6. Overloading</a> <a href="#ref-for-dfn-identifier-30">(2)</a> <a href="#ref-for-dfn-identifier-31">(3)</a>
<li><a href="#ref-for-dfn-identifier-32">2.3. Namespaces</a>
<li><a href="#ref-for-dfn-identifier-33">2.4. Dictionaries</a> <a href="#ref-for-dfn-identifier-34">(2)</a> <a href="#ref-for-dfn-identifier-35">(3)</a> <a href="#ref-for-dfn-identifier-36">(4)</a>
<li><a href="#ref-for-dfn-identifier-37">2.7. Callback functions</a>
<li><a href="#ref-for-dfn-identifier-38">2.8. Typedefs</a>
<li><a href="#ref-for-dfn-identifier-39">2.9. Implements statements</a> <a href="#ref-for-dfn-identifier-40">(2)</a>
<li><a href="#ref-for-dfn-identifier-41">2.11.19. Interface types</a> <a href="#ref-for-dfn-identifier-42">(2)</a>
<li><a href="#ref-for-dfn-identifier-43">2.11.20. Dictionary types</a> <a href="#ref-for-dfn-identifier-44">(2)</a>
<li><a href="#ref-for-dfn-identifier-45">2.11.21. Enumeration types</a> <a href="#ref-for-dfn-identifier-46">(2)</a>
<li><a href="#ref-for-dfn-identifier-47">2.11.22. Callback function types</a> <a href="#ref-for-dfn-identifier-48">(2)</a>
<li><a href="#ref-for-dfn-identifier-49">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-identifier-50">(2)</a>
<li><a href="#ref-for-dfn-identifier-51">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-identifier-52">3.3.14. [PutForwards]</a> <a href="#ref-for-dfn-identifier-53">(2)</a>
<li><a href="#ref-for-dfn-identifier-54">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-identifier-55">(2)</a>
<li><a href="#ref-for-dfn-identifier-56">3.4. Security</a>
<li><a href="#ref-for-dfn-identifier-57">3.6. Interfaces</a>
<li><a href="#ref-for-dfn-identifier-58">3.6.1.1. Interface object [[Call]] method</a> <a href="#ref-for-dfn-identifier-59">(2)</a>
<li><a href="#ref-for-dfn-identifier-60">3.6.2. Named constructors</a> <a href="#ref-for-dfn-identifier-61">(2)</a> <a href="#ref-for-dfn-identifier-62">(3)</a>
<li><a href="#ref-for-dfn-identifier-63">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-identifier-64">(2)</a>
<li><a href="#ref-for-dfn-identifier-65">3.6.4. Named properties object</a>
<li><a href="#ref-for-dfn-identifier-66">3.6.4.1. Named properties object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-identifier-67">3.6.5. Constants</a>
<li><a href="#ref-for-dfn-identifier-68">3.6.6. Attributes</a> <a href="#ref-for-dfn-identifier-69">(2)</a> <a href="#ref-for-dfn-identifier-70">(3)</a>
<li><a href="#ref-for-dfn-identifier-71">3.6.7. Operations</a> <a href="#ref-for-dfn-identifier-72">(2)</a> <a href="#ref-for-dfn-identifier-73">(3)</a> <a href="#ref-for-dfn-identifier-74">(4)</a> <a href="#ref-for-dfn-identifier-75">(5)</a> <a href="#ref-for-dfn-identifier-76">(6)</a>
<li><a href="#ref-for-dfn-identifier-77">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-identifier-78">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-identifier-79">3.6.9.4. Default iterator objects</a>
<li><a href="#ref-for-dfn-identifier-80">3.6.9.5. Iterator prototype object</a>
<li><a href="#ref-for-dfn-identifier-81">3.8. Platform objects implementing interfaces</a>
<li><a href="#ref-for-dfn-identifier-82">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a> <a href="#ref-for-dfn-identifier-83">(2)</a>
<li><a href="#ref-for-dfn-identifier-84">3.8.4. Invoking a platform object indexed property setter</a>
<li><a href="#ref-for-dfn-identifier-85">3.8.5. Invoking a platform object named property setter</a>
<li><a href="#ref-for-dfn-identifier-86">3.8.8. Platform object [[Delete]] method</a>
<li><a href="#ref-for-dfn-identifier-87">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-identifier-88">(2)</a> <a href="#ref-for-dfn-identifier-89">(3)</a>
<li><a href="#ref-for-dfn-identifier-90">3.11. Namespaces</a>
<li><a href="#ref-for-dfn-identifier-91">3.11.1. Namespace object</a>
<li><a href="#ref-for-dfn-identifier-92">IDL grammar</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-reserved-identifier">
<b><a href="#dfn-reserved-identifier">#dfn-reserved-identifier</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-reserved-identifier-1">3.3.10. [NamedConstructor]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-interface">
<b><a href="#dfn-interface">#dfn-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-interface-1">2. Interface definition language</a> <a href="#ref-for-dfn-interface-2">(2)</a>
<li><a href="#ref-for-dfn-interface-3">2.1. Names</a> <a href="#ref-for-dfn-interface-4">(2)</a> <a href="#ref-for-dfn-interface-5">(3)</a> <a href="#ref-for-dfn-interface-6">(4)</a>
<li><a href="#ref-for-dfn-interface-7">2.2. Interfaces</a> <a href="#ref-for-dfn-interface-8">(2)</a> <a href="#ref-for-dfn-interface-9">(3)</a> <a href="#ref-for-dfn-interface-10">(4)</a> <a href="#ref-for-dfn-interface-11">(5)</a> <a href="#ref-for-dfn-interface-12">(6)</a> <a href="#ref-for-dfn-interface-13">(7)</a>
<li><a href="#ref-for-dfn-interface-14">2.2.1. Constants</a> <a href="#ref-for-dfn-interface-15">(2)</a> <a href="#ref-for-dfn-interface-16">(3)</a>
<li><a href="#ref-for-dfn-interface-17">2.2.2. Attributes</a> <a href="#ref-for-dfn-interface-18">(2)</a> <a href="#ref-for-dfn-interface-19">(3)</a>
<li><a href="#ref-for-dfn-interface-20">2.2.3. Operations</a> <a href="#ref-for-dfn-interface-21">(2)</a> <a href="#ref-for-dfn-interface-22">(3)</a> <a href="#ref-for-dfn-interface-23">(4)</a> <a href="#ref-for-dfn-interface-24">(5)</a> <a href="#ref-for-dfn-interface-25">(6)</a>
<li><a href="#ref-for-dfn-interface-26">2.2.4. Special operations</a> <a href="#ref-for-dfn-interface-27">(2)</a>
<li><a href="#ref-for-dfn-interface-28">2.2.4.1. Legacy callers</a> <a href="#ref-for-dfn-interface-29">(2)</a>
<li><a href="#ref-for-dfn-interface-30">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-interface-31">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-interface-32">2.2.4.4. Indexed properties</a>
<li><a href="#ref-for-dfn-interface-33">2.2.4.5. Named properties</a>
<li><a href="#ref-for-dfn-interface-34">2.2.5. Static attributes and operations</a>
<li><a href="#ref-for-dfn-interface-35">2.2.6. Overloading</a> <a href="#ref-for-dfn-interface-36">(2)</a> <a href="#ref-for-dfn-interface-37">(3)</a> <a href="#ref-for-dfn-interface-38">(4)</a> <a href="#ref-for-dfn-interface-39">(5)</a> <a href="#ref-for-dfn-interface-40">(6)</a> <a href="#ref-for-dfn-interface-41">(7)</a> <a href="#ref-for-dfn-interface-42">(8)</a>
<li><a href="#ref-for-dfn-interface-43">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-interface-44">(2)</a>
<li><a href="#ref-for-dfn-interface-45">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-interface-46">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-interface-47">2.9. Implements statements</a> <a href="#ref-for-dfn-interface-48">(2)</a>
<li><a href="#ref-for-dfn-interface-49">2.10. Objects implementing interfaces</a>
<li><a href="#ref-for-dfn-interface-50">2.11.19. Interface types</a>
<li><a href="#ref-for-dfn-interface-51">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-interface-52">3. ECMAScript binding</a>
<li><a href="#ref-for-dfn-interface-53">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-interface-54">3.2.20. Interface types</a>
<li><a href="#ref-for-dfn-interface-55">3.2.25.1. Creating a sequence from an iterable</a>
<li><a href="#ref-for-dfn-interface-56">3.3.2. [Constructor]</a>
<li><a href="#ref-for-dfn-interface-57">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-interface-58">(2)</a> <a href="#ref-for-dfn-interface-59">(3)</a>
<li><a href="#ref-for-dfn-interface-60">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-dfn-interface-61">(2)</a> <a href="#ref-for-dfn-interface-62">(3)</a> <a href="#ref-for-dfn-interface-63">(4)</a>
<li><a href="#ref-for-dfn-interface-64">3.3.6. [LegacyArrayClass]</a> <a href="#ref-for-dfn-interface-65">(2)</a>
<li><a href="#ref-for-dfn-interface-66">3.3.7. [LegacyUnenumerableNamedProperties]</a>
<li><a href="#ref-for-dfn-interface-67">3.3.9. [LenientThis]</a>
<li><a href="#ref-for-dfn-interface-68">3.3.10. [NamedConstructor]</a>
<li><a href="#ref-for-dfn-interface-69">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-interface-70">3.3.13. [OverrideBuiltins]</a> <a href="#ref-for-dfn-interface-71">(2)</a>
<li><a href="#ref-for-dfn-interface-72">3.3.14. [PutForwards]</a> <a href="#ref-for-dfn-interface-73">(2)</a>
<li><a href="#ref-for-dfn-interface-74">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-interface-75">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-interface-76">(2)</a>
<li><a href="#ref-for-dfn-interface-77">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-interface-78">(2)</a>
<li><a href="#ref-for-dfn-interface-79">3.6. Interfaces</a> <a href="#ref-for-dfn-interface-80">(2)</a>
<li><a href="#ref-for-dfn-interface-81">3.6.1. Interface object</a>
<li><a href="#ref-for-dfn-interface-82">3.6.1.1. Interface object [[Call]] method</a> <a href="#ref-for-dfn-interface-83">(2)</a> <a href="#ref-for-dfn-interface-84">(3)</a> <a href="#ref-for-dfn-interface-85">(4)</a>
<li><a href="#ref-for-dfn-interface-86">3.6.2. Named constructors</a> <a href="#ref-for-dfn-interface-87">(2)</a> <a href="#ref-for-dfn-interface-88">(3)</a> <a href="#ref-for-dfn-interface-89">(4)</a>
<li><a href="#ref-for-dfn-interface-90">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-interface-91">(2)</a> <a href="#ref-for-dfn-interface-92">(3)</a>
<li><a href="#ref-for-dfn-interface-93">3.6.4. Named properties object</a> <a href="#ref-for-dfn-interface-94">(2)</a>
<li><a href="#ref-for-dfn-interface-95">3.6.4.1. Named properties object [[GetOwnProperty]] method</a> <a href="#ref-for-dfn-interface-96">(2)</a>
<li><a href="#ref-for-dfn-interface-97">3.6.5. Constants</a>
<li><a href="#ref-for-dfn-interface-98">3.6.6. Attributes</a> <a href="#ref-for-dfn-interface-99">(2)</a> <a href="#ref-for-dfn-interface-100">(3)</a>
<li><a href="#ref-for-dfn-interface-101">3.6.7. Operations</a> <a href="#ref-for-dfn-interface-102">(2)</a> <a href="#ref-for-dfn-interface-103">(3)</a>
<li><a href="#ref-for-dfn-interface-104">3.6.7.1. Stringifiers</a> <a href="#ref-for-dfn-interface-105">(2)</a>
<li><a href="#ref-for-dfn-interface-106">3.6.7.2. Serializers</a> <a href="#ref-for-dfn-interface-107">(2)</a> <a href="#ref-for-dfn-interface-108">(3)</a>
<li><a href="#ref-for-dfn-interface-109">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-interface-110">(2)</a> <a href="#ref-for-dfn-interface-111">(3)</a>
<li><a href="#ref-for-dfn-interface-112">3.6.8.2. forEach</a> <a href="#ref-for-dfn-interface-113">(2)</a>
<li><a href="#ref-for-dfn-interface-114">3.6.9.1. entries</a>
<li><a href="#ref-for-dfn-interface-115">3.6.9.2. keys</a> <a href="#ref-for-dfn-interface-116">(2)</a>
<li><a href="#ref-for-dfn-interface-117">3.6.9.3. values</a> <a href="#ref-for-dfn-interface-118">(2)</a>
<li><a href="#ref-for-dfn-interface-119">3.6.9.4. Default iterator objects</a> <a href="#ref-for-dfn-interface-120">(2)</a> <a href="#ref-for-dfn-interface-121">(3)</a> <a href="#ref-for-dfn-interface-122">(4)</a>
<li><a href="#ref-for-dfn-interface-123">3.6.9.5. Iterator prototype object</a> <a href="#ref-for-dfn-interface-124">(2)</a> <a href="#ref-for-dfn-interface-125">(3)</a> <a href="#ref-for-dfn-interface-126">(4)</a>
<li><a href="#ref-for-dfn-interface-127">3.6.10. Maplike declarations</a> <a href="#ref-for-dfn-interface-128">(2)</a>
<li><a href="#ref-for-dfn-interface-129">3.6.11. Setlike declarations</a> <a href="#ref-for-dfn-interface-130">(2)</a>
<li><a href="#ref-for-dfn-interface-131">3.7. Implements statements</a>
<li><a href="#ref-for-dfn-interface-132">3.8.1. Indexed and named properties</a> <a href="#ref-for-dfn-interface-133">(2)</a> <a href="#ref-for-dfn-interface-134">(3)</a>
<li><a href="#ref-for-dfn-interface-135">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-interface-136">3.8.3. Platform object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-interface-137">3.8.6. Platform object [[Set]] method</a>
<li><a href="#ref-for-dfn-interface-138">3.8.7. Platform object [[DefineOwnProperty]] method</a> <a href="#ref-for-dfn-interface-139">(2)</a> <a href="#ref-for-dfn-interface-140">(3)</a>
<li><a href="#ref-for-dfn-interface-141">3.8.8. Platform object [[Delete]] method</a> <a href="#ref-for-dfn-interface-142">(2)</a>
<li><a href="#ref-for-dfn-interface-143">3.8.9. Platform object [[Call]] method</a>
<li><a href="#ref-for-dfn-interface-144">3.8.10. Property enumeration</a> <a href="#ref-for-dfn-interface-145">(2)</a>
<li><a href="#ref-for-dfn-interface-146">3.9. User objects implementing callback interfaces</a>
<li><a href="#ref-for-dfn-interface-147">3.14. Creating and throwing exceptions</a>
<li><a href="#ref-for-dfn-interface-148">3.15. Handling exceptions</a>
<li><a href="#ref-for-dfn-interface-149">IDL grammar</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-interface-member">
<b><a href="#dfn-interface-member">#dfn-interface-member</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-interface-member-1">2.1. Names</a>
<li><a href="#ref-for-dfn-interface-member-2">2.2.1. Constants</a>
<li><a href="#ref-for-dfn-interface-member-3">2.2.2. Attributes</a> <a href="#ref-for-dfn-interface-member-4">(2)</a>
<li><a href="#ref-for-dfn-interface-member-5">2.2.3. Operations</a> <a href="#ref-for-dfn-interface-member-6">(2)</a>
<li><a href="#ref-for-dfn-interface-member-7">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-dfn-interface-member-8">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-interface-member-9">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-interface-member-10">2.12. Extended attributes</a>
<li><a href="#ref-for-dfn-interface-member-11">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-interface-member-12">(2)</a>
<li><a href="#ref-for-dfn-interface-member-13">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-dfn-interface-member-14">(2)</a> <a href="#ref-for-dfn-interface-member-15">(3)</a> <a href="#ref-for-dfn-interface-member-16">(4)</a>
<li><a href="#ref-for-dfn-interface-member-17">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-interface-member-18">(2)</a>
<li><a href="#ref-for-dfn-interface-member-19">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-interface-member-20">(2)</a>
<li><a href="#ref-for-dfn-interface-member-21">3.6.10.5. clear</a>
<li><a href="#ref-for-dfn-interface-member-22">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-interface-member-23">3.6.10.7. set</a>
<li><a href="#ref-for-dfn-interface-member-24">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-interface-member-25">3.6.11.6. clear</a>
<li><a href="#ref-for-dfn-interface-member-26">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-inherit">
<b><a href="#dfn-inherit">#dfn-inherit</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-inherit-1">2.2. Interfaces</a> <a href="#ref-for-dfn-inherit-2">(2)</a> <a href="#ref-for-dfn-inherit-3">(3)</a> <a href="#ref-for-dfn-inherit-4">(4)</a>
<li><a href="#ref-for-dfn-inherit-5">2.4. Dictionaries</a> <a href="#ref-for-dfn-inherit-6">(2)</a>
<li><a href="#ref-for-dfn-inherit-7">2.9. Implements statements</a> <a href="#ref-for-dfn-inherit-8">(2)</a>
<li><a href="#ref-for-dfn-inherit-9">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-inherit-10">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-dfn-inherit-11">(2)</a>
<li><a href="#ref-for-dfn-inherit-12">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-inherit-13">3.3.17. [SecureContext]</a>
<li><a href="#ref-for-dfn-inherit-14">3.9. User objects implementing callback interfaces</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-inherited-interfaces">
<b><a href="#dfn-inherited-interfaces">#dfn-inherited-interfaces</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-inherited-interfaces-1">2.2. Interfaces</a> <a href="#ref-for-dfn-inherited-interfaces-2">(2)</a>
<li><a href="#ref-for-dfn-inherited-interfaces-3">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-inherited-interfaces-4">(2)</a> <a href="#ref-for-dfn-inherited-interfaces-5">(3)</a>
<li><a href="#ref-for-dfn-inherited-interfaces-6">2.2.8. Maplike declarations</a> <a href="#ref-for-dfn-inherited-interfaces-7">(2)</a> <a href="#ref-for-dfn-inherited-interfaces-8">(3)</a> <a href="#ref-for-dfn-inherited-interfaces-9">(4)</a>
<li><a href="#ref-for-dfn-inherited-interfaces-10">2.2.9. Setlike declarations</a> <a href="#ref-for-dfn-inherited-interfaces-11">(2)</a> <a href="#ref-for-dfn-inherited-interfaces-12">(3)</a> <a href="#ref-for-dfn-inherited-interfaces-13">(4)</a>
<li><a href="#ref-for-dfn-inherited-interfaces-14">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-inherited-interfaces-15">3.3.20. [Unforgeable]</a>
<li><a href="#ref-for-dfn-inherited-interfaces-16">3.6.3. Interface prototype object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-callback-interface">
<b><a href="#dfn-callback-interface">#dfn-callback-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-callback-interface-1">2.2. Interfaces</a> <a href="#ref-for-dfn-callback-interface-2">(2)</a> <a href="#ref-for-dfn-callback-interface-3">(3)</a> <a href="#ref-for-dfn-callback-interface-4">(4)</a> <a href="#ref-for-dfn-callback-interface-5">(5)</a> <a href="#ref-for-dfn-callback-interface-6">(6)</a>
<li><a href="#ref-for-dfn-callback-interface-7">2.2.4. Special operations</a>
<li><a href="#ref-for-dfn-callback-interface-8">2.2.5. Static attributes and operations</a>
<li><a href="#ref-for-dfn-callback-interface-9">2.2.6. Overloading</a> <a href="#ref-for-dfn-callback-interface-10">(2)</a>
<li><a href="#ref-for-dfn-callback-interface-11">2.7. Callback functions</a>
<li><a href="#ref-for-dfn-callback-interface-12">2.9. Implements statements</a>
<li><a href="#ref-for-dfn-callback-interface-13">2.10. Objects implementing interfaces</a> <a href="#ref-for-dfn-callback-interface-14">(2)</a> <a href="#ref-for-dfn-callback-interface-15">(3)</a>
<li><a href="#ref-for-dfn-callback-interface-16">2.11.19. Interface types</a>
<li><a href="#ref-for-dfn-callback-interface-17">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-callback-interface-18">3.3.2. [Constructor]</a>
<li><a href="#ref-for-dfn-callback-interface-19">3.3.10. [NamedConstructor]</a>
<li><a href="#ref-for-dfn-callback-interface-20">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-callback-interface-21">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-dfn-callback-interface-22">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-callback-interface-23">3.3.19. [TreatNullAs]</a>
<li><a href="#ref-for-dfn-callback-interface-24">3.5. Overload resolution algorithm</a>
<li><a href="#ref-for-dfn-callback-interface-25">3.6. Interfaces</a>
<li><a href="#ref-for-dfn-callback-interface-26">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-callback-interface-27">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-partial-interface">
<b><a href="#dfn-partial-interface">#dfn-partial-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-partial-interface-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-partial-interface-2">2.1. Names</a>
<li><a href="#ref-for-dfn-partial-interface-3">2.2. Interfaces</a> <a href="#ref-for-dfn-partial-interface-4">(2)</a> <a href="#ref-for-dfn-partial-interface-5">(3)</a>
<li><a href="#ref-for-dfn-partial-interface-6">2.2.6. Overloading</a> <a href="#ref-for-dfn-partial-interface-7">(2)</a>
<li><a href="#ref-for-dfn-partial-interface-8">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-partial-interface-9">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-partial-interface-10">3.3.13. [OverrideBuiltins]</a>
<li><a href="#ref-for-dfn-partial-interface-11">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-partial-interface-12">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-constant">
<b><a href="#dfn-constant">#dfn-constant</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-constant-1">2.1. Names</a> <a href="#ref-for-dfn-constant-2">(2)</a>
<li><a href="#ref-for-dfn-constant-3">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-constant-4">2.2.1. Constants</a> <a href="#ref-for-dfn-constant-5">(2)</a> <a href="#ref-for-dfn-constant-6">(3)</a> <a href="#ref-for-dfn-constant-7">(4)</a> <a href="#ref-for-dfn-constant-8">(5)</a> <a href="#ref-for-dfn-constant-9">(6)</a> <a href="#ref-for-dfn-constant-10">(7)</a>
<li><a href="#ref-for-dfn-constant-11">2.2.3. Operations</a> <a href="#ref-for-dfn-constant-12">(2)</a>
<li><a href="#ref-for-dfn-constant-13">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-constant-14">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-constant-15">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-constant-16">2.7. Callback functions</a>
<li><a href="#ref-for-dfn-constant-17">2.11. Types</a>
<li><a href="#ref-for-dfn-constant-18">2.11.24. Sequence types — sequence<T></a>
<li><a href="#ref-for-dfn-constant-19">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-dfn-constant-20">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-constant-21">3.6. Interfaces</a>
<li><a href="#ref-for-dfn-constant-22">3.6.1. Interface object</a> <a href="#ref-for-dfn-constant-23">(2)</a>
<li><a href="#ref-for-dfn-constant-24">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-constant-25">3.6.5. Constants</a> <a href="#ref-for-dfn-constant-26">(2)</a> <a href="#ref-for-dfn-constant-27">(3)</a>
<li><a href="#ref-for-dfn-constant-28">3.7. Implements statements</a>
<li><a href="#ref-for-dfn-constant-29">3.9. User objects implementing callback interfaces</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-attribute">
<b><a href="#dfn-attribute">#dfn-attribute</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-attribute-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-attribute-2">2.1. Names</a> <a href="#ref-for-dfn-attribute-3">(2)</a> <a href="#ref-for-dfn-attribute-4">(3)</a>
<li><a href="#ref-for-dfn-attribute-5">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-attribute-6">2.2.2. Attributes</a> <a href="#ref-for-dfn-attribute-7">(2)</a> <a href="#ref-for-dfn-attribute-8">(3)</a>
<li><a href="#ref-for-dfn-attribute-9">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-attribute-10">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-attribute-11">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-dfn-attribute-12">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-attribute-13">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-attribute-14">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-attribute-15">2.5. Exceptions</a>
<li><a href="#ref-for-dfn-attribute-16">2.6. Enumerations</a> <a href="#ref-for-dfn-attribute-17">(2)</a> <a href="#ref-for-dfn-attribute-18">(3)</a> <a href="#ref-for-dfn-attribute-19">(4)</a>
<li><a href="#ref-for-dfn-attribute-20">2.11. Types</a>
<li><a href="#ref-for-dfn-attribute-21">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-attribute-22">2.11.24. Sequence types — sequence<T></a> <a href="#ref-for-dfn-attribute-23">(2)</a>
<li><a href="#ref-for-dfn-attribute-24">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-dfn-attribute-25">3.2.4. byte</a> <a href="#ref-for-dfn-attribute-26">(2)</a>
<li><a href="#ref-for-dfn-attribute-27">3.2.5. octet</a> <a href="#ref-for-dfn-attribute-28">(2)</a>
<li><a href="#ref-for-dfn-attribute-29">3.2.6. short</a> <a href="#ref-for-dfn-attribute-30">(2)</a>
<li><a href="#ref-for-dfn-attribute-31">3.2.7. unsigned short</a> <a href="#ref-for-dfn-attribute-32">(2)</a>
<li><a href="#ref-for-dfn-attribute-33">3.2.8. long</a> <a href="#ref-for-dfn-attribute-34">(2)</a>
<li><a href="#ref-for-dfn-attribute-35">3.2.9. unsigned long</a> <a href="#ref-for-dfn-attribute-36">(2)</a>
<li><a href="#ref-for-dfn-attribute-37">3.2.10. long long</a> <a href="#ref-for-dfn-attribute-38">(2)</a>
<li><a href="#ref-for-dfn-attribute-39">3.2.11. unsigned long long</a> <a href="#ref-for-dfn-attribute-40">(2)</a>
<li><a href="#ref-for-dfn-attribute-41">3.2.16. DOMString</a>
<li><a href="#ref-for-dfn-attribute-42">3.2.23. Callback function types</a>
<li><a href="#ref-for-dfn-attribute-43">3.2.24. Nullable types — T?</a>
<li><a href="#ref-for-dfn-attribute-44">3.2.25.1. Creating a sequence from an iterable</a>
<li><a href="#ref-for-dfn-attribute-45">3.3.1. [Clamp]</a>
<li><a href="#ref-for-dfn-attribute-46">3.3.6. [LegacyArrayClass]</a> <a href="#ref-for-dfn-attribute-47">(2)</a>
<li><a href="#ref-for-dfn-attribute-48">3.3.14. [PutForwards]</a> <a href="#ref-for-dfn-attribute-49">(2)</a> <a href="#ref-for-dfn-attribute-50">(3)</a> <a href="#ref-for-dfn-attribute-51">(4)</a>
<li><a href="#ref-for-dfn-attribute-52">3.3.15. [Replaceable]</a> <a href="#ref-for-dfn-attribute-53">(2)</a> <a href="#ref-for-dfn-attribute-54">(3)</a>
<li><a href="#ref-for-dfn-attribute-55">3.3.16. [SameObject]</a> <a href="#ref-for-dfn-attribute-56">(2)</a>
<li><a href="#ref-for-dfn-attribute-57">3.3.18. [TreatNonObjectAsNull]</a>
<li><a href="#ref-for-dfn-attribute-58">3.3.19. [TreatNullAs]</a>
<li><a href="#ref-for-dfn-attribute-59">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-attribute-60">(2)</a> <a href="#ref-for-dfn-attribute-61">(3)</a> <a href="#ref-for-dfn-attribute-62">(4)</a>
<li><a href="#ref-for-dfn-attribute-63">3.4. Security</a>
<li><a href="#ref-for-dfn-attribute-64">3.6.6. Attributes</a> <a href="#ref-for-dfn-attribute-65">(2)</a> <a href="#ref-for-dfn-attribute-66">(3)</a> <a href="#ref-for-dfn-attribute-67">(4)</a> <a href="#ref-for-dfn-attribute-68">(5)</a> <a href="#ref-for-dfn-attribute-69">(6)</a> <a href="#ref-for-dfn-attribute-70">(7)</a> <a href="#ref-for-dfn-attribute-71">(8)</a> <a href="#ref-for-dfn-attribute-72">(9)</a>
<li><a href="#ref-for-dfn-attribute-73">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-attribute-74">3.6.8.1. @@iterator</a>
<li><a href="#ref-for-dfn-attribute-75">3.7. Implements statements</a> <a href="#ref-for-dfn-attribute-76">(2)</a>
<li><a href="#ref-for-dfn-attribute-77">3.9. User objects implementing callback interfaces</a>
<li><a href="#ref-for-dfn-attribute-78">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-regular-attribute">
<b><a href="#dfn-regular-attribute">#dfn-regular-attribute</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-regular-attribute-1">2.2.2. Attributes</a> <a href="#ref-for-dfn-regular-attribute-2">(2)</a> <a href="#ref-for-dfn-regular-attribute-3">(3)</a>
<li><a href="#ref-for-dfn-regular-attribute-4">3.3.3. [EnforceRange]</a>
<li><a href="#ref-for-dfn-regular-attribute-5">3.3.8. [LenientSetter]</a> <a href="#ref-for-dfn-regular-attribute-6">(2)</a>
<li><a href="#ref-for-dfn-regular-attribute-7">3.3.9. [LenientThis]</a>
<li><a href="#ref-for-dfn-regular-attribute-8">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-dfn-regular-attribute-9">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-regular-attribute-10">3.3.21. [Unscopable]</a> <a href="#ref-for-dfn-regular-attribute-11">(2)</a>
<li><a href="#ref-for-dfn-regular-attribute-12">3.6.1. Interface object</a>
<li><a href="#ref-for-dfn-regular-attribute-13">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-regular-attribute-14">3.6.6. Attributes</a> <a href="#ref-for-dfn-regular-attribute-15">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-read-only">
<b><a href="#dfn-read-only">#dfn-read-only</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-read-only-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-read-only-2">2.2.2. Attributes</a> <a href="#ref-for-dfn-read-only-3">(2)</a>
<li><a href="#ref-for-dfn-read-only-4">3.3.1. [Clamp]</a>
<li><a href="#ref-for-dfn-read-only-5">3.3.3. [EnforceRange]</a>
<li><a href="#ref-for-dfn-read-only-6">3.3.8. [LenientSetter]</a> <a href="#ref-for-dfn-read-only-7">(2)</a>
<li><a href="#ref-for-dfn-read-only-8">3.3.14. [PutForwards]</a> <a href="#ref-for-dfn-read-only-9">(2)</a>
<li><a href="#ref-for-dfn-read-only-10">3.3.15. [Replaceable]</a> <a href="#ref-for-dfn-read-only-11">(2)</a>
<li><a href="#ref-for-dfn-read-only-12">3.3.16. [SameObject]</a> <a href="#ref-for-dfn-read-only-13">(2)</a>
<li><a href="#ref-for-dfn-read-only-14">3.6.6. Attributes</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-inherit-getter">
<b><a href="#dfn-inherit-getter">#dfn-inherit-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-inherit-getter-1">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-inherit-getter-2">3.6.6. Attributes</a>
<li><a href="#ref-for-dfn-inherit-getter-3">3.6.7.1. Stringifiers</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-operation">
<b><a href="#dfn-operation">#dfn-operation</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-operation-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-operation-2">2.1. Names</a> <a href="#ref-for-dfn-operation-3">(2)</a>
<li><a href="#ref-for-dfn-operation-4">2.2. Interfaces</a> <a href="#ref-for-dfn-operation-5">(2)</a>
<li><a href="#ref-for-dfn-operation-6">2.2.3. Operations</a> <a href="#ref-for-dfn-operation-7">(2)</a> <a href="#ref-for-dfn-operation-8">(3)</a>
<li><a href="#ref-for-dfn-operation-9">2.2.4.1. Legacy callers</a>
<li><a href="#ref-for-dfn-operation-10">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-operation-11">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-operation-12">2.2.4.4. Indexed properties</a> <a href="#ref-for-dfn-operation-13">(2)</a> <a href="#ref-for-dfn-operation-14">(3)</a>
<li><a href="#ref-for-dfn-operation-15">2.2.4.5. Named properties</a> <a href="#ref-for-dfn-operation-16">(2)</a>
<li><a href="#ref-for-dfn-operation-17">2.2.6. Overloading</a> <a href="#ref-for-dfn-operation-18">(2)</a> <a href="#ref-for-dfn-operation-19">(3)</a>
<li><a href="#ref-for-dfn-operation-20">2.4. Dictionaries</a> <a href="#ref-for-dfn-operation-21">(2)</a>
<li><a href="#ref-for-dfn-operation-22">2.5. Exceptions</a>
<li><a href="#ref-for-dfn-operation-23">2.6. Enumerations</a> <a href="#ref-for-dfn-operation-24">(2)</a> <a href="#ref-for-dfn-operation-25">(3)</a> <a href="#ref-for-dfn-operation-26">(4)</a>
<li><a href="#ref-for-dfn-operation-27">2.11. Types</a>
<li><a href="#ref-for-dfn-operation-28">2.11.24. Sequence types — sequence<T></a>
<li><a href="#ref-for-dfn-operation-29">2.12. Extended attributes</a>
<li><a href="#ref-for-dfn-operation-30">3.2.2. void</a>
<li><a href="#ref-for-dfn-operation-31">3.2.4. byte</a> <a href="#ref-for-dfn-operation-32">(2)</a>
<li><a href="#ref-for-dfn-operation-33">3.2.5. octet</a> <a href="#ref-for-dfn-operation-34">(2)</a>
<li><a href="#ref-for-dfn-operation-35">3.2.6. short</a> <a href="#ref-for-dfn-operation-36">(2)</a>
<li><a href="#ref-for-dfn-operation-37">3.2.7. unsigned short</a> <a href="#ref-for-dfn-operation-38">(2)</a>
<li><a href="#ref-for-dfn-operation-39">3.2.8. long</a> <a href="#ref-for-dfn-operation-40">(2)</a>
<li><a href="#ref-for-dfn-operation-41">3.2.9. unsigned long</a> <a href="#ref-for-dfn-operation-42">(2)</a>
<li><a href="#ref-for-dfn-operation-43">3.2.10. long long</a> <a href="#ref-for-dfn-operation-44">(2)</a>
<li><a href="#ref-for-dfn-operation-45">3.2.11. unsigned long long</a> <a href="#ref-for-dfn-operation-46">(2)</a>
<li><a href="#ref-for-dfn-operation-47">3.2.16. DOMString</a>
<li><a href="#ref-for-dfn-operation-48">3.2.25.1. Creating a sequence from an iterable</a>
<li><a href="#ref-for-dfn-operation-49">3.3.1. [Clamp]</a> <a href="#ref-for-dfn-operation-50">(2)</a>
<li><a href="#ref-for-dfn-operation-51">3.3.3. [EnforceRange]</a> <a href="#ref-for-dfn-operation-52">(2)</a>
<li><a href="#ref-for-dfn-operation-53">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-operation-54">3.3.11. [NewObject]</a> <a href="#ref-for-dfn-operation-55">(2)</a>
<li><a href="#ref-for-dfn-operation-56">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-operation-57">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-operation-58">(2)</a>
<li><a href="#ref-for-dfn-operation-59">3.3.19. [TreatNullAs]</a>
<li><a href="#ref-for-dfn-operation-60">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-operation-61">(2)</a> <a href="#ref-for-dfn-operation-62">(3)</a> <a href="#ref-for-dfn-operation-63">(4)</a>
<li><a href="#ref-for-dfn-operation-64">3.4. Security</a>
<li><a href="#ref-for-dfn-operation-65">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-operation-66">(2)</a>
<li><a href="#ref-for-dfn-operation-67">3.6.7. Operations</a> <a href="#ref-for-dfn-operation-68">(2)</a> <a href="#ref-for-dfn-operation-69">(3)</a>
<li><a href="#ref-for-dfn-operation-70">3.6.7.1. Stringifiers</a> <a href="#ref-for-dfn-operation-71">(2)</a>
<li><a href="#ref-for-dfn-operation-72">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-operation-73">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-operation-74">3.7. Implements statements</a> <a href="#ref-for-dfn-operation-75">(2)</a>
<li><a href="#ref-for-dfn-operation-76">3.10. Invoking callback functions</a>
<li><a href="#ref-for-dfn-operation-77">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-regular-operation">
<b><a href="#dfn-regular-operation">#dfn-regular-operation</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-regular-operation-1">2.2.3. Operations</a> <a href="#ref-for-dfn-regular-operation-2">(2)</a> <a href="#ref-for-dfn-regular-operation-3">(3)</a> <a href="#ref-for-dfn-regular-operation-4">(4)</a>
<li><a href="#ref-for-dfn-regular-operation-5">2.2.6. Overloading</a> <a href="#ref-for-dfn-regular-operation-6">(2)</a> <a href="#ref-for-dfn-regular-operation-7">(3)</a>
<li><a href="#ref-for-dfn-regular-operation-8">2.3. Namespaces</a>
<li><a href="#ref-for-dfn-regular-operation-9">3.3.11. [NewObject]</a> <a href="#ref-for-dfn-regular-operation-10">(2)</a>
<li><a href="#ref-for-dfn-regular-operation-11">3.3.20. [Unforgeable]</a>
<li><a href="#ref-for-dfn-regular-operation-12">3.3.21. [Unscopable]</a> <a href="#ref-for-dfn-regular-operation-13">(2)</a>
<li><a href="#ref-for-dfn-regular-operation-14">3.6.1. Interface object</a>
<li><a href="#ref-for-dfn-regular-operation-15">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-regular-operation-16">3.6.7. Operations</a> <a href="#ref-for-dfn-regular-operation-17">(2)</a>
<li><a href="#ref-for-dfn-regular-operation-18">3.9. User objects implementing callback interfaces</a>
<li><a href="#ref-for-dfn-regular-operation-19">3.11.1. Namespace object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-return-type">
<b><a href="#dfn-return-type">#dfn-return-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-return-type-1">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-return-type-2">2.5. Exceptions</a>
<li><a href="#ref-for-dfn-return-type-3">3.2.2. void</a>
<li><a href="#ref-for-dfn-return-type-4">3.3.11. [NewObject]</a>
<li><a href="#ref-for-dfn-return-type-5">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-return-type-6">3.8.8. Platform object [[Delete]] method</a>
<li><a href="#ref-for-dfn-return-type-7">3.9. User objects implementing callback interfaces</a>
<li><a href="#ref-for-dfn-return-type-8">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-void">
<b><a href="#idl-void">#idl-void</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-void-1">3.2.2. void</a> <a href="#ref-for-idl-void-2">(2)</a> <a href="#ref-for-idl-void-3">(3)</a>
<li><a href="#ref-for-idl-void-4">3.2.27. Promise types — Promise<T></a> <a href="#ref-for-idl-void-5">(2)</a>
<li><a href="#ref-for-idl-void-6">3.8.9. Platform object [[Call]] method</a>
<li><a href="#ref-for-idl-void-7">3.9. User objects implementing callback interfaces</a>
<li><a href="#ref-for-idl-void-8">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-variadic">
<b><a href="#dfn-variadic">#dfn-variadic</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-variadic-1">2.2.3. Operations</a> <a href="#ref-for-dfn-variadic-2">(2)</a> <a href="#ref-for-dfn-variadic-3">(3)</a> <a href="#ref-for-dfn-variadic-4">(4)</a>
<li><a href="#ref-for-dfn-variadic-5">2.2.4. Special operations</a>
<li><a href="#ref-for-dfn-variadic-6">2.2.6. Overloading</a> <a href="#ref-for-dfn-variadic-7">(2)</a> <a href="#ref-for-dfn-variadic-8">(3)</a> <a href="#ref-for-dfn-variadic-9">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-optional-argument">
<b><a href="#dfn-optional-argument">#dfn-optional-argument</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-optional-argument-1">2.2.3. Operations</a> <a href="#ref-for-dfn-optional-argument-2">(2)</a>
<li><a href="#ref-for-dfn-optional-argument-3">2.2.4. Special operations</a>
<li><a href="#ref-for-dfn-optional-argument-4">2.2.6. Overloading</a> <a href="#ref-for-dfn-optional-argument-5">(2)</a> <a href="#ref-for-dfn-optional-argument-6">(3)</a> <a href="#ref-for-dfn-optional-argument-7">(4)</a>
<li><a href="#ref-for-dfn-optional-argument-8">2.11.15. DOMString</a>
<li><a href="#ref-for-dfn-optional-argument-9">2.11.16. ByteString</a>
<li><a href="#ref-for-dfn-optional-argument-10">2.11.17. USVString</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-optional-argument-default-value">
<b><a href="#dfn-optional-argument-default-value">#dfn-optional-argument-default-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-optional-argument-default-value-1">2.2.1. Constants</a>
<li><a href="#ref-for-dfn-optional-argument-default-value-2">2.2.3. Operations</a> <a href="#ref-for-dfn-optional-argument-default-value-3">(2)</a> <a href="#ref-for-dfn-optional-argument-default-value-4">(3)</a> <a href="#ref-for-dfn-optional-argument-default-value-5">(4)</a> <a href="#ref-for-dfn-optional-argument-default-value-6">(5)</a>
<li><a href="#ref-for-dfn-optional-argument-default-value-7">2.4. Dictionaries</a> <a href="#ref-for-dfn-optional-argument-default-value-8">(2)</a>
<li><a href="#ref-for-dfn-optional-argument-default-value-9">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-optional-argument-default-value-10">(2)</a> <a href="#ref-for-dfn-optional-argument-default-value-11">(3)</a> <a href="#ref-for-dfn-optional-argument-default-value-12">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-code-unit">
<b><a href="#dfn-code-unit">#dfn-code-unit</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-code-unit-1">2.11.15. DOMString</a> <a href="#ref-for-dfn-code-unit-2">(2)</a> <a href="#ref-for-dfn-code-unit-3">(3)</a>
<li><a href="#ref-for-dfn-code-unit-4">2.11.17. USVString</a>
<li><a href="#ref-for-dfn-code-unit-5">2.11.21. Enumeration types</a>
<li><a href="#ref-for-dfn-code-unit-6">3.2.16. DOMString</a>
<li><a href="#ref-for-dfn-code-unit-7">3.2.18. USVString</a> <a href="#ref-for-dfn-code-unit-8">(2)</a>
<li><a href="#ref-for-dfn-code-unit-9">3.2.22. Enumeration types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-special-operation">
<b><a href="#dfn-special-operation">#dfn-special-operation</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-special-operation-1">2.1. Names</a>
<li><a href="#ref-for-dfn-special-operation-2">2.2.3. Operations</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-special-keyword">
<b><a href="#dfn-special-keyword">#dfn-special-keyword</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-special-keyword-1">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-special-keyword-2">2.2.4. Special operations</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-getter">
<b><a href="#dfn-getter">#dfn-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-getter-1">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-setter">
<b><a href="#dfn-setter">#dfn-setter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-setter-1">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-stringifier">
<b><a href="#dfn-stringifier">#dfn-stringifier</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-stringifier-1">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-stringifier-2">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-stringifier-3">3.6.7.1. Stringifiers</a> <a href="#ref-for-dfn-stringifier-4">(2)</a> <a href="#ref-for-dfn-stringifier-5">(3)</a> <a href="#ref-for-dfn-stringifier-6">(4)</a>
<li><a href="#ref-for-dfn-stringifier-7">3.8. Platform objects implementing interfaces</a>
<li><a href="#ref-for-dfn-stringifier-8">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-serializer">
<b><a href="#dfn-serializer">#dfn-serializer</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-serializer-1">2.2.4.3. Serializers</a> <a href="#ref-for-dfn-serializer-2">(2)</a> <a href="#ref-for-dfn-serializer-3">(3)</a>
<li><a href="#ref-for-dfn-serializer-4">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-serializer-5">3.6.7.2. Serializers</a> <a href="#ref-for-dfn-serializer-6">(2)</a> <a href="#ref-for-dfn-serializer-7">(3)</a>
<li><a href="#ref-for-dfn-serializer-8">3.8. Platform objects implementing interfaces</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-property-getter">
<b><a href="#dfn-named-property-getter">#dfn-named-property-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-property-getter-1">2.2.4. Special operations</a>
<li><a href="#ref-for-dfn-named-property-getter-2">2.2.4.5. Named properties</a> <a href="#ref-for-dfn-named-property-getter-3">(2)</a> <a href="#ref-for-dfn-named-property-getter-4">(3)</a>
<li><a href="#ref-for-dfn-named-property-getter-5">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-named-property-getter-6">3.3.7. [LegacyUnenumerableNamedProperties]</a>
<li><a href="#ref-for-dfn-named-property-getter-7">3.3.13. [OverrideBuiltins]</a> <a href="#ref-for-dfn-named-property-getter-8">(2)</a> <a href="#ref-for-dfn-named-property-getter-9">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-property-setter">
<b><a href="#dfn-named-property-setter">#dfn-named-property-setter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-property-setter-1">2.2.4.5. Named properties</a> <a href="#ref-for-dfn-named-property-setter-2">(2)</a>
<li><a href="#ref-for-dfn-named-property-setter-3">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-named-property-setter-4">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-named-property-setter-5">3.8.6. Platform object [[Set]] method</a>
<li><a href="#ref-for-dfn-named-property-setter-6">3.8.7. Platform object [[DefineOwnProperty]] method</a> <a href="#ref-for-dfn-named-property-setter-7">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-indexed-property-getter">
<b><a href="#dfn-indexed-property-getter">#dfn-indexed-property-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-indexed-property-getter-1">2.2.4.4. Indexed properties</a> <a href="#ref-for-dfn-indexed-property-getter-2">(2)</a> <a href="#ref-for-dfn-indexed-property-getter-3">(3)</a>
<li><a href="#ref-for-dfn-indexed-property-getter-4">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-dfn-indexed-property-getter-5">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-indexed-property-getter-6">(2)</a>
<li><a href="#ref-for-dfn-indexed-property-getter-7">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-indexed-property-getter-8">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-indexed-property-setter">
<b><a href="#dfn-indexed-property-setter">#dfn-indexed-property-setter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-indexed-property-setter-1">2.2.4.4. Indexed properties</a> <a href="#ref-for-dfn-indexed-property-setter-2">(2)</a>
<li><a href="#ref-for-dfn-indexed-property-setter-3">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-indexed-property-setter-4">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-indexed-property-setter-5">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-indexed-property-setter-6">3.8.6. Platform object [[Set]] method</a>
<li><a href="#ref-for-dfn-indexed-property-setter-7">3.8.7. Platform object [[DefineOwnProperty]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-property-deleter">
<b><a href="#dfn-named-property-deleter">#dfn-named-property-deleter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-property-deleter-1">2.2.4. Special operations</a> <a href="#ref-for-dfn-named-property-deleter-2">(2)</a>
<li><a href="#ref-for-dfn-named-property-deleter-3">2.2.4.5. Named properties</a> <a href="#ref-for-dfn-named-property-deleter-4">(2)</a>
<li><a href="#ref-for-dfn-named-property-deleter-5">3.8.8. Platform object [[Delete]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-legacy-callers">
<b><a href="#idl-legacy-callers">#idl-legacy-callers</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-legacy-callers-1">2.2.4.1. Legacy callers</a> <a href="#ref-for-idl-legacy-callers-2">(2)</a>
<li><a href="#ref-for-idl-legacy-callers-3">2.2.6. Overloading</a> <a href="#ref-for-idl-legacy-callers-4">(2)</a> <a href="#ref-for-idl-legacy-callers-5">(3)</a> <a href="#ref-for-idl-legacy-callers-6">(4)</a> <a href="#ref-for-idl-legacy-callers-7">(5)</a>
<li><a href="#ref-for-idl-legacy-callers-8">3.8.9. Platform object [[Call]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-stringification-behavior">
<b><a href="#dfn-stringification-behavior">#dfn-stringification-behavior</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-stringification-behavior-1">3.6.7.1. Stringifiers</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-serialization-behavior">
<b><a href="#dfn-serialization-behavior">#dfn-serialization-behavior</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-serialization-behavior-1">2.2.4.3. Serializers</a> <a href="#ref-for-dfn-serialization-behavior-2">(2)</a> <a href="#ref-for-dfn-serialization-behavior-3">(3)</a> <a href="#ref-for-dfn-serialization-behavior-4">(4)</a> <a href="#ref-for-dfn-serialization-behavior-5">(5)</a> <a href="#ref-for-dfn-serialization-behavior-6">(6)</a> <a href="#ref-for-dfn-serialization-behavior-7">(7)</a> <a href="#ref-for-dfn-serialization-behavior-8">(8)</a> <a href="#ref-for-dfn-serialization-behavior-9">(9)</a> <a href="#ref-for-dfn-serialization-behavior-10">(10)</a> <a href="#ref-for-dfn-serialization-behavior-11">(11)</a> <a href="#ref-for-dfn-serialization-behavior-12">(12)</a> <a href="#ref-for-dfn-serialization-behavior-13">(13)</a> <a href="#ref-for-dfn-serialization-behavior-14">(14)</a>
<li><a href="#ref-for-dfn-serialization-behavior-15">3.6.7.2. Serializers</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-serialized-value">
<b><a href="#dfn-serialized-value">#dfn-serialized-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-serialized-value-1">2.2.4.3. Serializers</a> <a href="#ref-for-dfn-serialized-value-2">(2)</a> <a href="#ref-for-dfn-serialized-value-3">(3)</a> <a href="#ref-for-dfn-serialized-value-4">(4)</a> <a href="#ref-for-dfn-serialized-value-5">(5)</a> <a href="#ref-for-dfn-serialized-value-6">(6)</a> <a href="#ref-for-dfn-serialized-value-7">(7)</a>
<li><a href="#ref-for-dfn-serialized-value-8">3.6.7.2. Serializers</a> <a href="#ref-for-dfn-serialized-value-9">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-serialization-pattern">
<b><a href="#dfn-serialization-pattern">#dfn-serialization-pattern</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-serialization-pattern-1">2.2.4.3. Serializers</a> <a href="#ref-for-dfn-serialization-pattern-2">(2)</a> <a href="#ref-for-dfn-serialization-pattern-3">(3)</a>
<li><a href="#ref-for-dfn-serialization-pattern-4">3.6.7.2. Serializers</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-serializable-type">
<b><a href="#dfn-serializable-type">#dfn-serializable-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-serializable-type-1">2.2.4.3. Serializers</a> <a href="#ref-for-dfn-serializable-type-2">(2)</a> <a href="#ref-for-dfn-serializable-type-3">(3)</a> <a href="#ref-for-dfn-serializable-type-4">(4)</a> <a href="#ref-for-dfn-serializable-type-5">(5)</a> <a href="#ref-for-dfn-serializable-type-6">(6)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-convert-to-serialized-value">
<b><a href="#dfn-convert-to-serialized-value">#dfn-convert-to-serialized-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-convert-to-serialized-value-1">2.2.4.3. Serializers</a> <a href="#ref-for-dfn-convert-to-serialized-value-2">(2)</a> <a href="#ref-for-dfn-convert-to-serialized-value-3">(3)</a> <a href="#ref-for-dfn-convert-to-serialized-value-4">(4)</a> <a href="#ref-for-dfn-convert-to-serialized-value-5">(5)</a> <a href="#ref-for-dfn-convert-to-serialized-value-6">(6)</a> <a href="#ref-for-dfn-convert-to-serialized-value-7">(7)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-indexed-properties">
<b><a href="#idl-indexed-properties">#idl-indexed-properties</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-indexed-properties-1">2.2.4. Special operations</a>
<li><a href="#ref-for-idl-indexed-properties-2">2.2.4.5. Named properties</a>
<li><a href="#ref-for-idl-indexed-properties-3">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-support-indexed-properties">
<b><a href="#dfn-support-indexed-properties">#dfn-support-indexed-properties</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-support-indexed-properties-1">2.2.4.4. Indexed properties</a>
<li><a href="#ref-for-dfn-support-indexed-properties-2">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-support-indexed-properties-3">(2)</a> <a href="#ref-for-dfn-support-indexed-properties-4">(3)</a> <a href="#ref-for-dfn-support-indexed-properties-5">(4)</a> <a href="#ref-for-dfn-support-indexed-properties-6">(5)</a>
<li><a href="#ref-for-dfn-support-indexed-properties-7">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-support-indexed-properties-8">3.6.9.4. Default iterator objects</a>
<li><a href="#ref-for-dfn-support-indexed-properties-9">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-support-indexed-properties-10">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-support-indexed-properties-11">3.8.3. Platform object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-support-indexed-properties-12">3.8.6. Platform object [[Set]] method</a> <a href="#ref-for-dfn-support-indexed-properties-13">(2)</a>
<li><a href="#ref-for-dfn-support-indexed-properties-14">3.8.7. Platform object [[DefineOwnProperty]] method</a> <a href="#ref-for-dfn-support-indexed-properties-15">(2)</a>
<li><a href="#ref-for-dfn-support-indexed-properties-16">3.8.8. Platform object [[Delete]] method</a> <a href="#ref-for-dfn-support-indexed-properties-17">(2)</a>
<li><a href="#ref-for-dfn-support-indexed-properties-18">3.8.10. Property enumeration</a> <a href="#ref-for-dfn-support-indexed-properties-19">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-supported-property-indices">
<b><a href="#dfn-supported-property-indices">#dfn-supported-property-indices</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-supported-property-indices-1">2.2.4.4. Indexed properties</a> <a href="#ref-for-dfn-supported-property-indices-2">(2)</a> <a href="#ref-for-dfn-supported-property-indices-3">(3)</a>
<li><a href="#ref-for-dfn-supported-property-indices-4">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-supported-property-indices-5">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-supported-property-indices-6">3.8.4. Invoking a platform object indexed property setter</a>
<li><a href="#ref-for-dfn-supported-property-indices-7">3.8.8. Platform object [[Delete]] method</a>
<li><a href="#ref-for-dfn-supported-property-indices-8">3.8.10. Property enumeration</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-determine-the-value-of-an-indexed-property">
<b><a href="#dfn-determine-the-value-of-an-indexed-property">#dfn-determine-the-value-of-an-indexed-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-determine-the-value-of-an-indexed-property-1">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-set-the-value-of-an-existing-indexed-property">
<b><a href="#dfn-set-the-value-of-an-existing-indexed-property">#dfn-set-the-value-of-an-existing-indexed-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-set-the-value-of-an-existing-indexed-property-1">3.8.4. Invoking a platform object indexed property setter</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-set-the-value-of-a-new-indexed-property">
<b><a href="#dfn-set-the-value-of-a-new-indexed-property">#dfn-set-the-value-of-a-new-indexed-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-set-the-value-of-a-new-indexed-property-1">3.8.4. Invoking a platform object indexed property setter</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-named-properties">
<b><a href="#idl-named-properties">#idl-named-properties</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-named-properties-1">2.2.4. Special operations</a>
<li><a href="#ref-for-idl-named-properties-2">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-idl-named-properties-3">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-support-named-properties">
<b><a href="#dfn-support-named-properties">#dfn-support-named-properties</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-support-named-properties-1">2.2.4.5. Named properties</a>
<li><a href="#ref-for-dfn-support-named-properties-2">3.3.7. [LegacyUnenumerableNamedProperties]</a>
<li><a href="#ref-for-dfn-support-named-properties-3">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-support-named-properties-4">3.6.4. Named properties object</a>
<li><a href="#ref-for-dfn-support-named-properties-5">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-support-named-properties-6">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-support-named-properties-7">3.8.3. Platform object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-support-named-properties-8">3.8.6. Platform object [[Set]] method</a> <a href="#ref-for-dfn-support-named-properties-9">(2)</a>
<li><a href="#ref-for-dfn-support-named-properties-10">3.8.7. Platform object [[DefineOwnProperty]] method</a> <a href="#ref-for-dfn-support-named-properties-11">(2)</a>
<li><a href="#ref-for-dfn-support-named-properties-12">3.8.8. Platform object [[Delete]] method</a> <a href="#ref-for-dfn-support-named-properties-13">(2)</a>
<li><a href="#ref-for-dfn-support-named-properties-14">3.8.10. Property enumeration</a> <a href="#ref-for-dfn-support-named-properties-15">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-supported-property-names">
<b><a href="#dfn-supported-property-names">#dfn-supported-property-names</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-supported-property-names-1">2.2.4.5. Named properties</a> <a href="#ref-for-dfn-supported-property-names-2">(2)</a>
<li><a href="#ref-for-dfn-supported-property-names-3">3.3.13. [OverrideBuiltins]</a>
<li><a href="#ref-for-dfn-supported-property-names-4">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-supported-property-names-5">3.8.5. Invoking a platform object named property setter</a>
<li><a href="#ref-for-dfn-supported-property-names-6">3.8.7. Platform object [[DefineOwnProperty]] method</a>
<li><a href="#ref-for-dfn-supported-property-names-7">3.8.10. Property enumeration</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-determine-the-value-of-a-named-property">
<b><a href="#dfn-determine-the-value-of-a-named-property">#dfn-determine-the-value-of-a-named-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-determine-the-value-of-a-named-property-1">3.6.4.1. Named properties object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-determine-the-value-of-a-named-property-2">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-set-the-value-of-an-existing-named-property">
<b><a href="#dfn-set-the-value-of-an-existing-named-property">#dfn-set-the-value-of-an-existing-named-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-set-the-value-of-an-existing-named-property-1">3.8.5. Invoking a platform object named property setter</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-set-the-value-of-a-new-named-property">
<b><a href="#dfn-set-the-value-of-a-new-named-property">#dfn-set-the-value-of-a-new-named-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-set-the-value-of-a-new-named-property-1">3.8.5. Invoking a platform object named property setter</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-delete-an-existing-named-property">
<b><a href="#dfn-delete-an-existing-named-property">#dfn-delete-an-existing-named-property</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-delete-an-existing-named-property-1">3.8.8. Platform object [[Delete]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-static-attribute">
<b><a href="#dfn-static-attribute">#dfn-static-attribute</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-static-attribute-1">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-static-attribute-2">2.2.2. Attributes</a> <a href="#ref-for-dfn-static-attribute-3">(2)</a> <a href="#ref-for-dfn-static-attribute-4">(3)</a>
<li><a href="#ref-for-dfn-static-attribute-5">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-dfn-static-attribute-6">3.3.3. [EnforceRange]</a>
<li><a href="#ref-for-dfn-static-attribute-7">3.3.9. [LenientThis]</a>
<li><a href="#ref-for-dfn-static-attribute-8">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-dfn-static-attribute-9">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-static-attribute-10">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-static-attribute-11">(2)</a>
<li><a href="#ref-for-dfn-static-attribute-12">3.6.6. Attributes</a> <a href="#ref-for-dfn-static-attribute-13">(2)</a> <a href="#ref-for-dfn-static-attribute-14">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-static-operation">
<b><a href="#dfn-static-operation">#dfn-static-operation</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-static-operation-1">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-static-operation-2">2.2.3. Operations</a> <a href="#ref-for-dfn-static-operation-3">(2)</a> <a href="#ref-for-dfn-static-operation-4">(3)</a>
<li><a href="#ref-for-dfn-static-operation-5">2.2.6. Overloading</a> <a href="#ref-for-dfn-static-operation-6">(2)</a>
<li><a href="#ref-for-dfn-static-operation-7">3.3.11. [NewObject]</a> <a href="#ref-for-dfn-static-operation-8">(2)</a>
<li><a href="#ref-for-dfn-static-operation-9">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-static-operation-10">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-static-operation-11">(2)</a> <a href="#ref-for-dfn-static-operation-12">(3)</a>
<li><a href="#ref-for-dfn-static-operation-13">3.6.1. Interface object</a>
<li><a href="#ref-for-dfn-static-operation-14">3.6.7. Operations</a> <a href="#ref-for-dfn-static-operation-15">(2)</a> <a href="#ref-for-dfn-static-operation-16">(3)</a> <a href="#ref-for-dfn-static-operation-17">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-overloaded">
<b><a href="#dfn-overloaded">#dfn-overloaded</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-overloaded-1">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-overloaded-2">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-overloaded-3">3.3.17. [SecureContext]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-effective-overload-set">
<b><a href="#dfn-effective-overload-set">#dfn-effective-overload-set</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-effective-overload-set-1">2.2.6. Overloading</a> <a href="#ref-for-dfn-effective-overload-set-2">(2)</a> <a href="#ref-for-dfn-effective-overload-set-3">(3)</a>
<li><a href="#ref-for-dfn-effective-overload-set-4">3.5. Overload resolution algorithm</a>
<li><a href="#ref-for-dfn-effective-overload-set-5">3.6.1.1. Interface object [[Call]] method</a> <a href="#ref-for-dfn-effective-overload-set-6">(2)</a>
<li><a href="#ref-for-dfn-effective-overload-set-7">3.6.2. Named constructors</a> <a href="#ref-for-dfn-effective-overload-set-8">(2)</a>
<li><a href="#ref-for-dfn-effective-overload-set-9">3.6.7. Operations</a> <a href="#ref-for-dfn-effective-overload-set-10">(2)</a> <a href="#ref-for-dfn-effective-overload-set-11">(3)</a>
<li><a href="#ref-for-dfn-effective-overload-set-12">3.8.9. Platform object [[Call]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-optionality-value">
<b><a href="#dfn-optionality-value">#dfn-optionality-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-optionality-value-1">2.2.6. Overloading</a> <a href="#ref-for-dfn-optionality-value-2">(2)</a>
<li><a href="#ref-for-dfn-optionality-value-3">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-optionality-value-4">(2)</a> <a href="#ref-for-dfn-optionality-value-5">(3)</a> <a href="#ref-for-dfn-optionality-value-6">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-distinguishable">
<b><a href="#dfn-distinguishable">#dfn-distinguishable</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-distinguishable-1">2.2.6. Overloading</a> <a href="#ref-for-dfn-distinguishable-2">(2)</a> <a href="#ref-for-dfn-distinguishable-3">(3)</a>
<li><a href="#ref-for-dfn-distinguishable-4">2.11.27. Union types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-distinguishing-argument-index">
<b><a href="#dfn-distinguishing-argument-index">#dfn-distinguishing-argument-index</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-distinguishing-argument-index-1">2.2.6. Overloading</a> <a href="#ref-for-dfn-distinguishing-argument-index-2">(2)</a> <a href="#ref-for-dfn-distinguishing-argument-index-3">(3)</a>
<li><a href="#ref-for-dfn-distinguishing-argument-index-4">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-distinguishing-argument-index-5">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-iterable-declaration">
<b><a href="#dfn-iterable-declaration">#dfn-iterable-declaration</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-iterable-declaration-1">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-iterable-declaration-2">(2)</a> <a href="#ref-for-dfn-iterable-declaration-3">(3)</a> <a href="#ref-for-dfn-iterable-declaration-4">(4)</a> <a href="#ref-for-dfn-iterable-declaration-5">(5)</a>
<li><a href="#ref-for-dfn-iterable-declaration-6">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-iterable-declaration-7">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-iterable-declaration-8">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-iterable-declaration-9">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-iterable-declaration-10">(2)</a>
<li><a href="#ref-for-dfn-iterable-declaration-11">3.6.8.2. forEach</a> <a href="#ref-for-dfn-iterable-declaration-12">(2)</a>
<li><a href="#ref-for-dfn-iterable-declaration-13">3.6.9.1. entries</a>
<li><a href="#ref-for-dfn-iterable-declaration-14">3.6.9.2. keys</a> <a href="#ref-for-dfn-iterable-declaration-15">(2)</a>
<li><a href="#ref-for-dfn-iterable-declaration-16">3.6.9.3. values</a> <a href="#ref-for-dfn-iterable-declaration-17">(2)</a>
<li><a href="#ref-for-dfn-iterable-declaration-18">3.7. Implements statements</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-value-iterator">
<b><a href="#dfn-value-iterator">#dfn-value-iterator</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-value-iterator-1">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-value-iterator-2">(2)</a> <a href="#ref-for-dfn-value-iterator-3">(3)</a> <a href="#ref-for-dfn-value-iterator-4">(4)</a> <a href="#ref-for-dfn-value-iterator-5">(5)</a> <a href="#ref-for-dfn-value-iterator-6">(6)</a>
<li><a href="#ref-for-dfn-value-iterator-7">3.6.9.1. entries</a>
<li><a href="#ref-for-dfn-value-iterator-8">3.6.9.2. keys</a>
<li><a href="#ref-for-dfn-value-iterator-9">3.6.9.3. values</a>
<li><a href="#ref-for-dfn-value-iterator-10">3.6.9.4. Default iterator objects</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-pair-iterator">
<b><a href="#dfn-pair-iterator">#dfn-pair-iterator</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-pair-iterator-1">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-pair-iterator-2">(2)</a> <a href="#ref-for-dfn-pair-iterator-3">(3)</a>
<li><a href="#ref-for-dfn-pair-iterator-4">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-pair-iterator-5">(2)</a>
<li><a href="#ref-for-dfn-pair-iterator-6">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-pair-iterator-7">3.6.9.1. entries</a>
<li><a href="#ref-for-dfn-pair-iterator-8">3.6.9.2. keys</a>
<li><a href="#ref-for-dfn-pair-iterator-9">3.6.9.3. values</a>
<li><a href="#ref-for-dfn-pair-iterator-10">3.6.9.4. Default iterator objects</a>
<li><a href="#ref-for-dfn-pair-iterator-11">3.6.9.5. Iterator prototype object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-value-pairs-to-iterate-over">
<b><a href="#dfn-value-pairs-to-iterate-over">#dfn-value-pairs-to-iterate-over</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-value-pairs-to-iterate-over-1">3.6.8.2. forEach</a> <a href="#ref-for-dfn-value-pairs-to-iterate-over-2">(2)</a>
<li><a href="#ref-for-dfn-value-pairs-to-iterate-over-3">3.6.9.5. Iterator prototype object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-maplike">
<b><a href="#dfn-maplike">#dfn-maplike</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-maplike-1">2.2.8. Maplike declarations</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-maplike-declaration">
<b><a href="#dfn-maplike-declaration">#dfn-maplike-declaration</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-maplike-declaration-1">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-dfn-maplike-declaration-2">2.2.8. Maplike declarations</a> <a href="#ref-for-dfn-maplike-declaration-3">(2)</a> <a href="#ref-for-dfn-maplike-declaration-4">(3)</a>
<li><a href="#ref-for-dfn-maplike-declaration-5">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-maplike-declaration-6">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-maplike-declaration-7">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-maplike-declaration-8">(2)</a> <a href="#ref-for-dfn-maplike-declaration-9">(3)</a> <a href="#ref-for-dfn-maplike-declaration-10">(4)</a> <a href="#ref-for-dfn-maplike-declaration-11">(5)</a>
<li><a href="#ref-for-dfn-maplike-declaration-12">3.6.8.2. forEach</a> <a href="#ref-for-dfn-maplike-declaration-13">(2)</a> <a href="#ref-for-dfn-maplike-declaration-14">(3)</a> <a href="#ref-for-dfn-maplike-declaration-15">(4)</a>
<li><a href="#ref-for-dfn-maplike-declaration-16">3.6.10. Maplike declarations</a> <a href="#ref-for-dfn-maplike-declaration-17">(2)</a>
<li><a href="#ref-for-dfn-maplike-declaration-18">3.6.10.4. get and has</a>
<li><a href="#ref-for-dfn-maplike-declaration-19">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-maplike-declaration-20">3.6.10.7. set</a>
<li><a href="#ref-for-dfn-maplike-declaration-21">3.7. Implements statements</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-map-entries">
<b><a href="#dfn-map-entries">#dfn-map-entries</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-map-entries-1">2.2.8. Maplike declarations</a> <a href="#ref-for-dfn-map-entries-2">(2)</a>
<li><a href="#ref-for-dfn-map-entries-3">3.6.10. Maplike declarations</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-setlike">
<b><a href="#dfn-setlike">#dfn-setlike</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-setlike-1">2.2.9. Setlike declarations</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-setlike-declaration">
<b><a href="#dfn-setlike-declaration">#dfn-setlike-declaration</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-setlike-declaration-1">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-dfn-setlike-declaration-2">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-setlike-declaration-3">2.2.9. Setlike declarations</a> <a href="#ref-for-dfn-setlike-declaration-4">(2)</a> <a href="#ref-for-dfn-setlike-declaration-5">(3)</a>
<li><a href="#ref-for-dfn-setlike-declaration-6">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-setlike-declaration-7">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-setlike-declaration-8">(2)</a> <a href="#ref-for-dfn-setlike-declaration-9">(3)</a> <a href="#ref-for-dfn-setlike-declaration-10">(4)</a>
<li><a href="#ref-for-dfn-setlike-declaration-11">3.6.8.2. forEach</a> <a href="#ref-for-dfn-setlike-declaration-12">(2)</a> <a href="#ref-for-dfn-setlike-declaration-13">(3)</a>
<li><a href="#ref-for-dfn-setlike-declaration-14">3.6.11. Setlike declarations</a> <a href="#ref-for-dfn-setlike-declaration-15">(2)</a>
<li><a href="#ref-for-dfn-setlike-declaration-16">3.6.11.4. has</a>
<li><a href="#ref-for-dfn-setlike-declaration-17">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-setlike-declaration-18">3.7. Implements statements</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-set-entries">
<b><a href="#dfn-set-entries">#dfn-set-entries</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-set-entries-1">2.2.9. Setlike declarations</a> <a href="#ref-for-dfn-set-entries-2">(2)</a>
<li><a href="#ref-for-dfn-set-entries-3">3.6.11. Setlike declarations</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-namespace">
<b><a href="#dfn-namespace">#dfn-namespace</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-namespace-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-namespace-2">2.1. Names</a> <a href="#ref-for-dfn-namespace-3">(2)</a> <a href="#ref-for-dfn-namespace-4">(3)</a>
<li><a href="#ref-for-dfn-namespace-5">2.3. Namespaces</a>
<li><a href="#ref-for-dfn-namespace-6">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-namespace-7">(2)</a>
<li><a href="#ref-for-dfn-namespace-8">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-namespace-9">(2)</a>
<li><a href="#ref-for-dfn-namespace-10">3.6.7. Operations</a> <a href="#ref-for-dfn-namespace-11">(2)</a>
<li><a href="#ref-for-dfn-namespace-12">3.11. Namespaces</a>
<li><a href="#ref-for-dfn-namespace-13">3.11.1. Namespace object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-namespace-member">
<b><a href="#dfn-namespace-member">#dfn-namespace-member</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-namespace-member-1">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-namespace-member-2">2.12. Extended attributes</a>
<li><a href="#ref-for-dfn-namespace-member-3">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-namespace-member-4">(2)</a>
<li><a href="#ref-for-dfn-namespace-member-5">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-namespace-member-6">(2)</a>
<li><a href="#ref-for-dfn-namespace-member-7">3.11.1. Namespace object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-partial-namespace">
<b><a href="#dfn-partial-namespace">#dfn-partial-namespace</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-partial-namespace-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-partial-namespace-2">2.1. Names</a>
<li><a href="#ref-for-dfn-partial-namespace-3">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-partial-namespace-4">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-partial-namespace-5">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-dictionary">
<b><a href="#dfn-dictionary">#dfn-dictionary</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-dictionary-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-dictionary-2">2.1. Names</a> <a href="#ref-for-dfn-dictionary-3">(2)</a> <a href="#ref-for-dfn-dictionary-4">(3)</a>
<li><a href="#ref-for-dfn-dictionary-5">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-dictionary-6">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-dictionary-7">2.2.4. Special operations</a>
<li><a href="#ref-for-dfn-dictionary-8">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-dictionary-9">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-dictionary-10">2.11.20. Dictionary types</a>
<li><a href="#ref-for-dfn-dictionary-11">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-dictionary-12">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-dictionary-member">
<b><a href="#dfn-dictionary-member">#dfn-dictionary-member</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-dictionary-member-1">2.1. Names</a> <a href="#ref-for-dfn-dictionary-member-2">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-3">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-dictionary-member-4">2.4. Dictionaries</a> <a href="#ref-for-dfn-dictionary-member-5">(2)</a> <a href="#ref-for-dfn-dictionary-member-6">(3)</a> <a href="#ref-for-dfn-dictionary-member-7">(4)</a> <a href="#ref-for-dfn-dictionary-member-8">(5)</a>
<li><a href="#ref-for-dfn-dictionary-member-9">2.11.15. DOMString</a>
<li><a href="#ref-for-dfn-dictionary-member-10">2.11.16. ByteString</a>
<li><a href="#ref-for-dfn-dictionary-member-11">2.11.17. USVString</a>
<li><a href="#ref-for-dfn-dictionary-member-12">2.11.21. Enumeration types</a>
<li><a href="#ref-for-dfn-dictionary-member-13">2.12. Extended attributes</a>
<li><a href="#ref-for-dfn-dictionary-member-14">3.2.4. byte</a> <a href="#ref-for-dfn-dictionary-member-15">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-16">3.2.5. octet</a> <a href="#ref-for-dfn-dictionary-member-17">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-18">3.2.6. short</a> <a href="#ref-for-dfn-dictionary-member-19">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-20">3.2.7. unsigned short</a> <a href="#ref-for-dfn-dictionary-member-21">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-22">3.2.8. long</a> <a href="#ref-for-dfn-dictionary-member-23">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-24">3.2.9. unsigned long</a> <a href="#ref-for-dfn-dictionary-member-25">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-26">3.2.10. long long</a> <a href="#ref-for-dfn-dictionary-member-27">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-28">3.2.11. unsigned long long</a> <a href="#ref-for-dfn-dictionary-member-29">(2)</a>
<li><a href="#ref-for-dfn-dictionary-member-30">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-dictionary-member-31">(2)</a> <a href="#ref-for-dfn-dictionary-member-32">(3)</a> <a href="#ref-for-dfn-dictionary-member-33">(4)</a> <a href="#ref-for-dfn-dictionary-member-34">(5)</a>
<li><a href="#ref-for-dfn-dictionary-member-35">3.3.1. [Clamp]</a>
<li><a href="#ref-for-dfn-dictionary-member-36">3.3.3. [EnforceRange]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-inherit-dictionary">
<b><a href="#dfn-inherit-dictionary">#dfn-inherit-dictionary</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-inherit-dictionary-1">2.4. Dictionaries</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-inherited-dictionaries">
<b><a href="#dfn-inherited-dictionaries">#dfn-inherited-dictionaries</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-inherited-dictionaries-1">2.4. Dictionaries</a> <a href="#ref-for-dfn-inherited-dictionaries-2">(2)</a> <a href="#ref-for-dfn-inherited-dictionaries-3">(3)</a>
<li><a href="#ref-for-dfn-inherited-dictionaries-4">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-inherited-dictionaries-5">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-present">
<b><a href="#dfn-present">#dfn-present</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-present-1">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-present-2">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-present-3">(2)</a> <a href="#ref-for-dfn-present-4">(3)</a> <a href="#ref-for-dfn-present-5">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-dictionary-member-default-value">
<b><a href="#dfn-dictionary-member-default-value">#dfn-dictionary-member-default-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-dictionary-member-default-value-1">2.2.1. Constants</a>
<li><a href="#ref-for-dfn-dictionary-member-default-value-2">2.4. Dictionaries</a> <a href="#ref-for-dfn-dictionary-member-default-value-3">(2)</a> <a href="#ref-for-dfn-dictionary-member-default-value-4">(3)</a> <a href="#ref-for-dfn-dictionary-member-default-value-5">(4)</a> <a href="#ref-for-dfn-dictionary-member-default-value-6">(5)</a>
<li><a href="#ref-for-dfn-dictionary-member-default-value-7">2.11.21. Enumeration types</a>
<li><a href="#ref-for-dfn-dictionary-member-default-value-8">3.2.21. Dictionary types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="required-dictionary-member">
<b><a href="#required-dictionary-member">#required-dictionary-member</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-required-dictionary-member-1">2.2.3. Operations</a>
<li><a href="#ref-for-required-dictionary-member-2">2.4. Dictionaries</a>
<li><a href="#ref-for-required-dictionary-member-3">3.2.21. Dictionary types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-partial-dictionary">
<b><a href="#dfn-partial-dictionary">#dfn-partial-dictionary</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-partial-dictionary-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-partial-dictionary-2">2.1. Names</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-exception">
<b><a href="#dfn-exception">#dfn-exception</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-exception-1">3.15. Handling exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-exception-error-name">
<b><a href="#dfn-exception-error-name">#dfn-exception-error-name</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-exception-error-name-1">2.5. Exceptions</a> <a href="#ref-for-dfn-exception-error-name-2">(2)</a> <a href="#ref-for-dfn-exception-error-name-3">(3)</a> <a href="#ref-for-dfn-exception-error-name-4">(4)</a> <a href="#ref-for-dfn-exception-error-name-5">(5)</a>
<li><a href="#ref-for-dfn-exception-error-name-6">3.14. Creating and throwing exceptions</a> <a href="#ref-for-dfn-exception-error-name-7">(2)</a> <a href="#ref-for-dfn-exception-error-name-8">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-simple-exception">
<b><a href="#dfn-simple-exception">#dfn-simple-exception</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-simple-exception-1">2.5. Exceptions</a> <a href="#ref-for-dfn-simple-exception-2">(2)</a> <a href="#ref-for-dfn-simple-exception-3">(3)</a>
<li><a href="#ref-for-dfn-simple-exception-4">2.11.29. Error</a>
<li><a href="#ref-for-dfn-simple-exception-5">3.13. Exception objects</a>
<li><a href="#ref-for-dfn-simple-exception-6">3.14. Creating and throwing exceptions</a> <a href="#ref-for-dfn-simple-exception-7">(2)</a> <a href="#ref-for-dfn-simple-exception-8">(3)</a> <a href="#ref-for-dfn-simple-exception-9">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="exceptiondef-typeerror">
<b><a href="#exceptiondef-typeerror">#exceptiondef-typeerror</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-exceptiondef-typeerror-1">2.5. Exceptions</a>
<li><a href="#ref-for-exceptiondef-typeerror-2">3.2.26. Open dictionaries — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-exceptiondef-typeerror-3">3.7. Implements statements</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-DOMException">
<b><a href="#dfn-DOMException">#dfn-DOMException</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-DOMException-1">2.5. Exceptions</a> <a href="#ref-for-dfn-DOMException-2">(2)</a> <a href="#ref-for-dfn-DOMException-3">(3)</a> <a href="#ref-for-dfn-DOMException-4">(4)</a> <a href="#ref-for-dfn-DOMException-5">(5)</a> <a href="#ref-for-dfn-DOMException-6">(6)</a>
<li><a href="#ref-for-dfn-DOMException-7">2.5.1. Error names</a> <a href="#ref-for-dfn-DOMException-8">(2)</a>
<li><a href="#ref-for-dfn-DOMException-9">2.10. Objects implementing interfaces</a>
<li><a href="#ref-for-dfn-DOMException-10">2.11. Types</a>
<li><a href="#ref-for-dfn-DOMException-11">2.11.29. Error</a>
<li><a href="#ref-for-dfn-DOMException-12">2.11.30. DOMException</a> <a href="#ref-for-dfn-DOMException-13">(2)</a> <a href="#ref-for-dfn-DOMException-14">(3)</a> <a href="#ref-for-dfn-DOMException-15">(4)</a>
<li><a href="#ref-for-dfn-DOMException-16">3.2.28. Union types</a> <a href="#ref-for-dfn-DOMException-17">(2)</a>
<li><a href="#ref-for-dfn-DOMException-18">3.2.30. Error</a>
<li><a href="#ref-for-dfn-DOMException-19">3.2.31. DOMException</a> <a href="#ref-for-dfn-DOMException-20">(2)</a> <a href="#ref-for-dfn-DOMException-21">(3)</a> <a href="#ref-for-dfn-DOMException-22">(4)</a> <a href="#ref-for-dfn-DOMException-23">(5)</a> <a href="#ref-for-dfn-DOMException-24">(6)</a> <a href="#ref-for-dfn-DOMException-25">(7)</a>
<li><a href="#ref-for-dfn-DOMException-26">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-DOMException-27">(2)</a>
<li><a href="#ref-for-dfn-DOMException-28">3.13. Exception objects</a> <a href="#ref-for-dfn-DOMException-29">(2)</a> <a href="#ref-for-dfn-DOMException-30">(3)</a>
<li><a href="#ref-for-dfn-DOMException-31">3.14. Creating and throwing exceptions</a> <a href="#ref-for-dfn-DOMException-32">(2)</a> <a href="#ref-for-dfn-DOMException-33">(3)</a> <a href="#ref-for-dfn-DOMException-34">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-create-exception">
<b><a href="#dfn-create-exception">#dfn-create-exception</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-create-exception-1">2.5. Exceptions</a> <a href="#ref-for-dfn-create-exception-2">(2)</a>
<li><a href="#ref-for-dfn-create-exception-3">3.14. Creating and throwing exceptions</a> <a href="#ref-for-dfn-create-exception-4">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-throw">
<b><a href="#dfn-throw">#dfn-throw</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-throw-1">2.5. Exceptions</a> <a href="#ref-for-dfn-throw-2">(2)</a>
<li><a href="#ref-for-dfn-throw-3">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-error-names-table">
<b><a href="#dfn-error-names-table">#dfn-error-names-table</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-error-names-table-1">2.5. Exceptions</a>
<li><a href="#ref-for-dfn-error-names-table-2">3.12.1. DOMException constructor object</a>
<li><a href="#ref-for-dfn-error-names-table-3">3.12.1.1. DOMException(message, name)</a>
<li><a href="#ref-for-dfn-error-names-table-4">3.12.2. DOMException prototype object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="indexsizeerror">
<b><a href="#indexsizeerror">#indexsizeerror</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-indexsizeerror-1">2.5. Exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="notsupportederror">
<b><a href="#notsupportederror">#notsupportederror</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-notsupportederror-1">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="syntaxerror">
<b><a href="#syntaxerror">#syntaxerror</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-syntaxerror-1">2.5. Exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-enumeration">
<b><a href="#dfn-enumeration">#dfn-enumeration</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-enumeration-1">2.1. Names</a> <a href="#ref-for-dfn-enumeration-2">(2)</a> <a href="#ref-for-dfn-enumeration-3">(3)</a>
<li><a href="#ref-for-dfn-enumeration-4">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-enumeration-5">2.2.3. Operations</a> <a href="#ref-for-dfn-enumeration-6">(2)</a> <a href="#ref-for-dfn-enumeration-7">(3)</a> <a href="#ref-for-dfn-enumeration-8">(4)</a>
<li><a href="#ref-for-dfn-enumeration-9">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-enumeration-10">2.4. Dictionaries</a> <a href="#ref-for-dfn-enumeration-11">(2)</a>
<li><a href="#ref-for-dfn-enumeration-12">2.6. Enumerations</a> <a href="#ref-for-dfn-enumeration-13">(2)</a> <a href="#ref-for-dfn-enumeration-14">(3)</a>
<li><a href="#ref-for-dfn-enumeration-15">2.11.21. Enumeration types</a> <a href="#ref-for-dfn-enumeration-16">(2)</a>
<li><a href="#ref-for-dfn-enumeration-17">3.2.22. Enumeration types</a> <a href="#ref-for-dfn-enumeration-18">(2)</a> <a href="#ref-for-dfn-enumeration-19">(3)</a>
<li><a href="#ref-for-dfn-enumeration-20">3.6.6. Attributes</a> <a href="#ref-for-dfn-enumeration-21">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-enumeration-value">
<b><a href="#dfn-enumeration-value">#dfn-enumeration-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-enumeration-value-1">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-enumeration-value-2">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-enumeration-value-3">2.6. Enumerations</a>
<li><a href="#ref-for-dfn-enumeration-value-4">2.11.21. Enumeration types</a>
<li><a href="#ref-for-dfn-enumeration-value-5">3.2.22. Enumeration types</a> <a href="#ref-for-dfn-enumeration-value-6">(2)</a>
<li><a href="#ref-for-dfn-enumeration-value-7">3.6.6. Attributes</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-callback-function">
<b><a href="#dfn-callback-function">#dfn-callback-function</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-callback-function-1">2.1. Names</a> <a href="#ref-for-dfn-callback-function-2">(2)</a> <a href="#ref-for-dfn-callback-function-3">(3)</a>
<li><a href="#ref-for-dfn-callback-function-4">2.2. Interfaces</a> <a href="#ref-for-dfn-callback-function-5">(2)</a> <a href="#ref-for-dfn-callback-function-6">(3)</a>
<li><a href="#ref-for-dfn-callback-function-7">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-callback-function-8">2.2.3. Operations</a> <a href="#ref-for-dfn-callback-function-9">(2)</a> <a href="#ref-for-dfn-callback-function-10">(3)</a>
<li><a href="#ref-for-dfn-callback-function-11">2.2.6. Overloading</a> <a href="#ref-for-dfn-callback-function-12">(2)</a>
<li><a href="#ref-for-dfn-callback-function-13">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-callback-function-14">2.7. Callback functions</a> <a href="#ref-for-dfn-callback-function-15">(2)</a> <a href="#ref-for-dfn-callback-function-16">(3)</a>
<li><a href="#ref-for-dfn-callback-function-17">2.11.22. Callback function types</a> <a href="#ref-for-dfn-callback-function-18">(2)</a>
<li><a href="#ref-for-dfn-callback-function-19">3.2.23. Callback function types</a>
<li><a href="#ref-for-dfn-callback-function-20">3.2.24. Nullable types — T?</a>
<li><a href="#ref-for-dfn-callback-function-21">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-callback-function-22">3.3.18. [TreatNonObjectAsNull]</a> <a href="#ref-for-dfn-callback-function-23">(2)</a> <a href="#ref-for-dfn-callback-function-24">(3)</a> <a href="#ref-for-dfn-callback-function-25">(4)</a> <a href="#ref-for-dfn-callback-function-26">(5)</a>
<li><a href="#ref-for-dfn-callback-function-27">3.5. Overload resolution algorithm</a>
<li><a href="#ref-for-dfn-callback-function-28">3.10. Invoking callback functions</a>
<li><a href="#ref-for-dfn-callback-function-29">4.4. Function</a>
<li><a href="#ref-for-dfn-callback-function-30">4.5. VoidFunction</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-typedef">
<b><a href="#dfn-typedef">#dfn-typedef</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-typedef-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-typedef-2">2.1. Names</a> <a href="#ref-for-dfn-typedef-3">(2)</a> <a href="#ref-for-dfn-typedef-4">(3)</a> <a href="#ref-for-dfn-typedef-5">(4)</a>
<li><a href="#ref-for-dfn-typedef-6">2.2.1. Constants</a>
<li><a href="#ref-for-dfn-typedef-7">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-typedef-8">2.2.3. Operations</a> <a href="#ref-for-dfn-typedef-9">(2)</a>
<li><a href="#ref-for-dfn-typedef-10">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-typedef-11">2.8. Typedefs</a> <a href="#ref-for-dfn-typedef-12">(2)</a> <a href="#ref-for-dfn-typedef-13">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-implements-statement">
<b><a href="#dfn-implements-statement">#dfn-implements-statement</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-implements-statement-1">2. Interface definition language</a>
<li><a href="#ref-for-dfn-implements-statement-2">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-implements-statement-3">2.9. Implements statements</a> <a href="#ref-for-dfn-implements-statement-4">(2)</a> <a href="#ref-for-dfn-implements-statement-5">(3)</a> <a href="#ref-for-dfn-implements-statement-6">(4)</a>
<li><a href="#ref-for-dfn-implements-statement-7">3.6.7. Operations</a> <a href="#ref-for-dfn-implements-statement-8">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-supplemental-interface">
<b><a href="#dfn-supplemental-interface">#dfn-supplemental-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-supplemental-interface-1">2.9. Implements statements</a> <a href="#ref-for-dfn-supplemental-interface-2">(2)</a> <a href="#ref-for-dfn-supplemental-interface-3">(3)</a>
<li><a href="#ref-for-dfn-supplemental-interface-4">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-supplemental-interface-5">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-supplemental-interface-6">(2)</a>
<li><a href="#ref-for-dfn-supplemental-interface-7">3.8. Platform objects implementing interfaces</a>
<li><a href="#ref-for-dfn-supplemental-interface-8">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-consequential-interfaces">
<b><a href="#dfn-consequential-interfaces">#dfn-consequential-interfaces</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-consequential-interfaces-1">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-consequential-interfaces-2">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-consequential-interfaces-3">(2)</a> <a href="#ref-for-dfn-consequential-interfaces-4">(3)</a>
<li><a href="#ref-for-dfn-consequential-interfaces-5">2.2.8. Maplike declarations</a> <a href="#ref-for-dfn-consequential-interfaces-6">(2)</a> <a href="#ref-for-dfn-consequential-interfaces-7">(3)</a> <a href="#ref-for-dfn-consequential-interfaces-8">(4)</a>
<li><a href="#ref-for-dfn-consequential-interfaces-9">2.2.9. Setlike declarations</a> <a href="#ref-for-dfn-consequential-interfaces-10">(2)</a> <a href="#ref-for-dfn-consequential-interfaces-11">(3)</a> <a href="#ref-for-dfn-consequential-interfaces-12">(4)</a>
<li><a href="#ref-for-dfn-consequential-interfaces-13">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-consequential-interfaces-14">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-dfn-consequential-interfaces-15">(2)</a>
<li><a href="#ref-for-dfn-consequential-interfaces-16">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-consequential-interfaces-17">(2)</a> <a href="#ref-for-dfn-consequential-interfaces-18">(3)</a> <a href="#ref-for-dfn-consequential-interfaces-19">(4)</a> <a href="#ref-for-dfn-consequential-interfaces-20">(5)</a>
<li><a href="#ref-for-dfn-consequential-interfaces-21">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-consequential-interfaces-22">3.6.5. Constants</a>
<li><a href="#ref-for-dfn-consequential-interfaces-23">3.6.6. Attributes</a> <a href="#ref-for-dfn-consequential-interfaces-24">(2)</a>
<li><a href="#ref-for-dfn-consequential-interfaces-25">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-consequential-interfaces-26">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-consequential-interfaces-27">3.6.8.1. @@iterator</a>
<li><a href="#ref-for-dfn-consequential-interfaces-28">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-consequential-interfaces-29">3.6.9.1. entries</a>
<li><a href="#ref-for-dfn-consequential-interfaces-30">3.6.9.2. keys</a>
<li><a href="#ref-for-dfn-consequential-interfaces-31">3.6.9.3. values</a>
<li><a href="#ref-for-dfn-consequential-interfaces-32">3.6.10.5. clear</a>
<li><a href="#ref-for-dfn-consequential-interfaces-33">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-consequential-interfaces-34">3.6.10.7. set</a>
<li><a href="#ref-for-dfn-consequential-interfaces-35">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-consequential-interfaces-36">3.6.11.6. clear</a>
<li><a href="#ref-for-dfn-consequential-interfaces-37">3.7. Implements statements</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-platform-object">
<b><a href="#dfn-platform-object">#dfn-platform-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-platform-object-1">2.2. Interfaces</a>
<li><a href="#ref-for-dfn-platform-object-2">2.2.4.1. Legacy callers</a>
<li><a href="#ref-for-dfn-platform-object-3">2.2.4.4. Indexed properties</a>
<li><a href="#ref-for-dfn-platform-object-4">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-platform-object-5">2.4. Dictionaries</a> <a href="#ref-for-dfn-platform-object-6">(2)</a>
<li><a href="#ref-for-dfn-platform-object-7">2.11.24. Sequence types — sequence<T></a>
<li><a href="#ref-for-dfn-platform-object-8">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-dfn-platform-object-9">3. ECMAScript binding</a>
<li><a href="#ref-for-dfn-platform-object-10">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-platform-object-11">3.2. ECMAScript type mapping</a>
<li><a href="#ref-for-dfn-platform-object-12">3.2.2. void</a>
<li><a href="#ref-for-dfn-platform-object-13">3.2.20. Interface types</a>
<li><a href="#ref-for-dfn-platform-object-14">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-platform-object-15">3.3.13. [OverrideBuiltins]</a>
<li><a href="#ref-for-dfn-platform-object-16">3.3.15. [Replaceable]</a> <a href="#ref-for-dfn-platform-object-17">(2)</a>
<li><a href="#ref-for-dfn-platform-object-18">3.4. Security</a>
<li><a href="#ref-for-dfn-platform-object-19">3.5. Overload resolution algorithm</a>
<li><a href="#ref-for-dfn-platform-object-20">3.6.6. Attributes</a> <a href="#ref-for-dfn-platform-object-21">(2)</a> <a href="#ref-for-dfn-platform-object-22">(3)</a> <a href="#ref-for-dfn-platform-object-23">(4)</a>
<li><a href="#ref-for-dfn-platform-object-24">3.6.7. Operations</a> <a href="#ref-for-dfn-platform-object-25">(2)</a>
<li><a href="#ref-for-dfn-platform-object-26">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-platform-object-27">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-platform-object-28">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-platform-object-29">(2)</a> <a href="#ref-for-dfn-platform-object-30">(3)</a> <a href="#ref-for-dfn-platform-object-31">(4)</a>
<li><a href="#ref-for-dfn-platform-object-32">3.6.8.2. forEach</a> <a href="#ref-for-dfn-platform-object-33">(2)</a>
<li><a href="#ref-for-dfn-platform-object-34">3.6.9.2. keys</a> <a href="#ref-for-dfn-platform-object-35">(2)</a>
<li><a href="#ref-for-dfn-platform-object-36">3.6.9.3. values</a> <a href="#ref-for-dfn-platform-object-37">(2)</a>
<li><a href="#ref-for-dfn-platform-object-38">3.6.9.5. Iterator prototype object</a>
<li><a href="#ref-for-dfn-platform-object-39">3.6.10. Maplike declarations</a>
<li><a href="#ref-for-dfn-platform-object-40">3.6.10.1. size</a>
<li><a href="#ref-for-dfn-platform-object-41">3.6.10.4. get and has</a>
<li><a href="#ref-for-dfn-platform-object-42">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-platform-object-43">3.6.10.7. set</a>
<li><a href="#ref-for-dfn-platform-object-44">3.6.11. Setlike declarations</a>
<li><a href="#ref-for-dfn-platform-object-45">3.6.11.1. size</a>
<li><a href="#ref-for-dfn-platform-object-46">3.6.11.4. has</a>
<li><a href="#ref-for-dfn-platform-object-47">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-platform-object-48">3.8. Platform objects implementing interfaces</a> <a href="#ref-for-dfn-platform-object-49">(2)</a> <a href="#ref-for-dfn-platform-object-50">(3)</a> <a href="#ref-for-dfn-platform-object-51">(4)</a>
<li><a href="#ref-for-dfn-platform-object-52">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-platform-object-53">3.8.3. Platform object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-platform-object-54">3.8.6. Platform object [[Set]] method</a>
<li><a href="#ref-for-dfn-platform-object-55">3.8.7. Platform object [[DefineOwnProperty]] method</a>
<li><a href="#ref-for-dfn-platform-object-56">3.8.8. Platform object [[Delete]] method</a>
<li><a href="#ref-for-dfn-platform-object-57">3.8.9. Platform object [[Call]] method</a>
<li><a href="#ref-for-dfn-platform-object-58">3.8.10. Property enumeration</a>
<li><a href="#ref-for-dfn-platform-object-59">3.13. Exception objects</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-user-object">
<b><a href="#dfn-user-object">#dfn-user-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-user-object-1">2.2. Interfaces</a> <a href="#ref-for-dfn-user-object-2">(2)</a> <a href="#ref-for-dfn-user-object-3">(3)</a>
<li><a href="#ref-for-dfn-user-object-4">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-user-object-5">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-user-object-6">3.2.16. DOMString</a> <a href="#ref-for-dfn-user-object-7">(2)</a>
<li><a href="#ref-for-dfn-user-object-8">3.2.20. Interface types</a>
<li><a href="#ref-for-dfn-user-object-9">3.9. User objects implementing callback interfaces</a>
<li><a href="#ref-for-dfn-user-object-10">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-integer-type">
<b><a href="#dfn-integer-type">#dfn-integer-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-integer-type-1">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-integer-type-2">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-dfn-integer-type-3">2.11. Types</a>
<li><a href="#ref-for-dfn-integer-type-4">3.3.1. [Clamp]</a>
<li><a href="#ref-for-dfn-integer-type-5">3.3.3. [EnforceRange]</a>
<li><a href="#ref-for-dfn-integer-type-6">3.6.8.1. @@iterator</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-numeric-type">
<b><a href="#dfn-numeric-type">#dfn-numeric-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-numeric-type-1">2.11. Types</a>
<li><a href="#ref-for-dfn-numeric-type-2">3.2.28. Union types</a> <a href="#ref-for-dfn-numeric-type-3">(2)</a> <a href="#ref-for-dfn-numeric-type-4">(3)</a> <a href="#ref-for-dfn-numeric-type-5">(4)</a>
<li><a href="#ref-for-dfn-numeric-type-6">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-numeric-type-7">(2)</a> <a href="#ref-for-dfn-numeric-type-8">(3)</a> <a href="#ref-for-dfn-numeric-type-9">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-primitive-type">
<b><a href="#dfn-primitive-type">#dfn-primitive-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-primitive-type-1">2.2.1. Constants</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-string-type">
<b><a href="#dfn-string-type">#dfn-string-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-string-type-1">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-string-type-2">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-string-type-3">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-exception-type">
<b><a href="#dfn-exception-type">#dfn-exception-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-exception-type-1">2.11. Types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-typed-array-type">
<b><a href="#dfn-typed-array-type">#dfn-typed-array-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-typed-array-type-1">2.11. Types</a>
<li><a href="#ref-for-dfn-typed-array-type-2">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-typed-array-type-3">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-buffer-source-type">
<b><a href="#dfn-buffer-source-type">#dfn-buffer-source-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-buffer-source-type-1">2.11.31. Buffer source types</a>
<li><a href="#ref-for-dfn-buffer-source-type-2">3.2.32. Buffer source types</a> <a href="#ref-for-dfn-buffer-source-type-3">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-type-name">
<b><a href="#dfn-type-name">#dfn-type-name</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-type-name-1">2.11.1. any</a>
<li><a href="#ref-for-dfn-type-name-2">2.11.2. boolean</a>
<li><a href="#ref-for-dfn-type-name-3">2.11.3. byte</a>
<li><a href="#ref-for-dfn-type-name-4">2.11.4. octet</a>
<li><a href="#ref-for-dfn-type-name-5">2.11.5. short</a>
<li><a href="#ref-for-dfn-type-name-6">2.11.6. unsigned short</a>
<li><a href="#ref-for-dfn-type-name-7">2.11.7. long</a>
<li><a href="#ref-for-dfn-type-name-8">2.11.8. unsigned long</a>
<li><a href="#ref-for-dfn-type-name-9">2.11.9. long long</a>
<li><a href="#ref-for-dfn-type-name-10">2.11.10. unsigned long long</a>
<li><a href="#ref-for-dfn-type-name-11">2.11.11. float</a>
<li><a href="#ref-for-dfn-type-name-12">2.11.12. unrestricted float</a>
<li><a href="#ref-for-dfn-type-name-13">2.11.13. double</a>
<li><a href="#ref-for-dfn-type-name-14">2.11.14. unrestricted double</a>
<li><a href="#ref-for-dfn-type-name-15">2.11.15. DOMString</a>
<li><a href="#ref-for-dfn-type-name-16">2.11.16. ByteString</a>
<li><a href="#ref-for-dfn-type-name-17">2.11.17. USVString</a>
<li><a href="#ref-for-dfn-type-name-18">2.11.18. object</a>
<li><a href="#ref-for-dfn-type-name-19">2.11.19. Interface types</a>
<li><a href="#ref-for-dfn-type-name-20">2.11.20. Dictionary types</a>
<li><a href="#ref-for-dfn-type-name-21">2.11.21. Enumeration types</a>
<li><a href="#ref-for-dfn-type-name-22">2.11.22. Callback function types</a>
<li><a href="#ref-for-dfn-type-name-23">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-type-name-24">2.11.24. Sequence types — sequence<T></a>
<li><a href="#ref-for-dfn-type-name-25">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-dfn-type-name-26">2.11.26. Promise types — Promise<T></a>
<li><a href="#ref-for-dfn-type-name-27">2.11.27. Union types</a>
<li><a href="#ref-for-dfn-type-name-28">2.11.28. RegExp</a>
<li><a href="#ref-for-dfn-type-name-29">2.11.29. Error</a>
<li><a href="#ref-for-dfn-type-name-30">2.11.30. DOMException</a>
<li><a href="#ref-for-dfn-type-name-31">2.11.31. Buffer source types</a>
<li><a href="#ref-for-dfn-type-name-32">2.11.32. Frozen array types — FrozenArray<T></a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-any">
<b><a href="#idl-any">#idl-any</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-any-1">2.11.1. any</a> <a href="#ref-for-idl-any-2">(2)</a> <a href="#ref-for-idl-any-3">(3)</a> <a href="#ref-for-idl-any-4">(4)</a> <a href="#ref-for-idl-any-5">(5)</a>
<li><a href="#ref-for-idl-any-6">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-idl-any-7">2.11.27. Union types</a> <a href="#ref-for-idl-any-8">(2)</a>
<li><a href="#ref-for-idl-any-9">3.2.1. any</a> <a href="#ref-for-idl-any-10">(2)</a> <a href="#ref-for-idl-any-11">(3)</a> <a href="#ref-for-idl-any-12">(4)</a>
<li><a href="#ref-for-idl-any-13">3.2.27. Promise types — Promise<T></a>
<li><a href="#ref-for-idl-any-14">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-specific-type">
<b><a href="#dfn-specific-type">#dfn-specific-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-specific-type-1">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-specific-type-2">2.11.1. any</a>
<li><a href="#ref-for-dfn-specific-type-3">2.11.27. Union types</a>
<li><a href="#ref-for-dfn-specific-type-4">3.2.1. any</a>
<li><a href="#ref-for-dfn-specific-type-5">3.2.28. Union types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-boolean">
<b><a href="#idl-boolean">#idl-boolean</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-boolean-1">2.2.1. Constants</a>
<li><a href="#ref-for-idl-boolean-2">2.2.3. Operations</a>
<li><a href="#ref-for-idl-boolean-3">2.2.4.3. Serializers</a> <a href="#ref-for-idl-boolean-4">(2)</a>
<li><a href="#ref-for-idl-boolean-5">2.4. Dictionaries</a>
<li><a href="#ref-for-idl-boolean-6">2.11. Types</a>
<li><a href="#ref-for-idl-boolean-7">2.11.2. boolean</a> <a href="#ref-for-idl-boolean-8">(2)</a> <a href="#ref-for-idl-boolean-9">(3)</a>
<li><a href="#ref-for-idl-boolean-10">3.2.1. any</a>
<li><a href="#ref-for-idl-boolean-11">3.2.3. boolean</a> <a href="#ref-for-idl-boolean-12">(2)</a> <a href="#ref-for-idl-boolean-13">(3)</a> <a href="#ref-for-idl-boolean-14">(4)</a>
<li><a href="#ref-for-idl-boolean-15">3.2.28. Union types</a> <a href="#ref-for-idl-boolean-16">(2)</a> <a href="#ref-for-idl-boolean-17">(3)</a> <a href="#ref-for-idl-boolean-18">(4)</a>
<li><a href="#ref-for-idl-boolean-19">3.5. Overload resolution algorithm</a> <a href="#ref-for-idl-boolean-20">(2)</a> <a href="#ref-for-idl-boolean-21">(3)</a> <a href="#ref-for-idl-boolean-22">(4)</a>
<li><a href="#ref-for-idl-boolean-23">3.8.8. Platform object [[Delete]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-byte">
<b><a href="#idl-byte">#idl-byte</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-byte-1">2.11. Types</a>
<li><a href="#ref-for-idl-byte-2">2.11.3. byte</a> <a href="#ref-for-idl-byte-3">(2)</a> <a href="#ref-for-idl-byte-4">(3)</a>
<li><a href="#ref-for-idl-byte-5">2.11.16. ByteString</a>
<li><a href="#ref-for-idl-byte-6">3.2.4. byte</a> <a href="#ref-for-idl-byte-7">(2)</a> <a href="#ref-for-idl-byte-8">(3)</a> <a href="#ref-for-idl-byte-9">(4)</a> <a href="#ref-for-idl-byte-10">(5)</a> <a href="#ref-for-idl-byte-11">(6)</a> <a href="#ref-for-idl-byte-12">(7)</a> <a href="#ref-for-idl-byte-13">(8)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-octet">
<b><a href="#idl-octet">#idl-octet</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-octet-1">2.11. Types</a>
<li><a href="#ref-for-idl-octet-2">2.11.4. octet</a> <a href="#ref-for-idl-octet-3">(2)</a> <a href="#ref-for-idl-octet-4">(3)</a>
<li><a href="#ref-for-idl-octet-5">2.11.16. ByteString</a>
<li><a href="#ref-for-idl-octet-6">3.2.5. octet</a> <a href="#ref-for-idl-octet-7">(2)</a> <a href="#ref-for-idl-octet-8">(3)</a> <a href="#ref-for-idl-octet-9">(4)</a> <a href="#ref-for-idl-octet-10">(5)</a> <a href="#ref-for-idl-octet-11">(6)</a> <a href="#ref-for-idl-octet-12">(7)</a>
<li><a href="#ref-for-idl-octet-13">3.3.1. [Clamp]</a> <a href="#ref-for-idl-octet-14">(2)</a>
<li><a href="#ref-for-idl-octet-15">3.3.3. [EnforceRange]</a> <a href="#ref-for-idl-octet-16">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-short">
<b><a href="#idl-short">#idl-short</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-short-1">2.11. Types</a>
<li><a href="#ref-for-idl-short-2">2.11.5. short</a> <a href="#ref-for-idl-short-3">(2)</a> <a href="#ref-for-idl-short-4">(3)</a>
<li><a href="#ref-for-idl-short-5">3.2.6. short</a> <a href="#ref-for-idl-short-6">(2)</a> <a href="#ref-for-idl-short-7">(3)</a> <a href="#ref-for-idl-short-8">(4)</a> <a href="#ref-for-idl-short-9">(5)</a> <a href="#ref-for-idl-short-10">(6)</a> <a href="#ref-for-idl-short-11">(7)</a> <a href="#ref-for-idl-short-12">(8)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-unsigned-short">
<b><a href="#idl-unsigned-short">#idl-unsigned-short</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-unsigned-short-1">2.11. Types</a>
<li><a href="#ref-for-idl-unsigned-short-2">2.11.6. unsigned short</a> <a href="#ref-for-idl-unsigned-short-3">(2)</a> <a href="#ref-for-idl-unsigned-short-4">(3)</a>
<li><a href="#ref-for-idl-unsigned-short-5">2.11.15. DOMString</a>
<li><a href="#ref-for-idl-unsigned-short-6">3.2.7. unsigned short</a> <a href="#ref-for-idl-unsigned-short-7">(2)</a> <a href="#ref-for-idl-unsigned-short-8">(3)</a> <a href="#ref-for-idl-unsigned-short-9">(4)</a> <a href="#ref-for-idl-unsigned-short-10">(5)</a> <a href="#ref-for-idl-unsigned-short-11">(6)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-long">
<b><a href="#idl-long">#idl-long</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-long-1">2.11. Types</a>
<li><a href="#ref-for-idl-long-2">2.11.1. any</a>
<li><a href="#ref-for-idl-long-3">2.11.7. long</a> <a href="#ref-for-idl-long-4">(2)</a> <a href="#ref-for-idl-long-5">(3)</a>
<li><a href="#ref-for-idl-long-6">3.2.8. long</a> <a href="#ref-for-idl-long-7">(2)</a> <a href="#ref-for-idl-long-8">(3)</a> <a href="#ref-for-idl-long-9">(4)</a> <a href="#ref-for-idl-long-10">(5)</a> <a href="#ref-for-idl-long-11">(6)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-unsigned-long">
<b><a href="#idl-unsigned-long">#idl-unsigned-long</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-unsigned-long-1">1. Introduction</a>
<li><a href="#ref-for-idl-unsigned-long-2">2.2.4. Special operations</a>
<li><a href="#ref-for-idl-unsigned-long-3">2.2.4.4. Indexed properties</a> <a href="#ref-for-idl-unsigned-long-4">(2)</a>
<li><a href="#ref-for-idl-unsigned-long-5">2.11. Types</a>
<li><a href="#ref-for-idl-unsigned-long-6">2.11.1. any</a>
<li><a href="#ref-for-idl-unsigned-long-7">2.11.8. unsigned long</a> <a href="#ref-for-idl-unsigned-long-8">(2)</a> <a href="#ref-for-idl-unsigned-long-9">(3)</a>
<li><a href="#ref-for-idl-unsigned-long-10">3.2.9. unsigned long</a> <a href="#ref-for-idl-unsigned-long-11">(2)</a> <a href="#ref-for-idl-unsigned-long-12">(3)</a> <a href="#ref-for-idl-unsigned-long-13">(4)</a> <a href="#ref-for-idl-unsigned-long-14">(5)</a> <a href="#ref-for-idl-unsigned-long-15">(6)</a>
<li><a href="#ref-for-idl-unsigned-long-16">3.3.6. [LegacyArrayClass]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-long-long">
<b><a href="#idl-long-long">#idl-long-long</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-long-long-1">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-long-long-2">2.11. Types</a>
<li><a href="#ref-for-idl-long-long-3">2.11.9. long long</a> <a href="#ref-for-idl-long-long-4">(2)</a> <a href="#ref-for-idl-long-long-5">(3)</a>
<li><a href="#ref-for-idl-long-long-6">3.2.10. long long</a> <a href="#ref-for-idl-long-long-7">(2)</a> <a href="#ref-for-idl-long-long-8">(3)</a> <a href="#ref-for-idl-long-long-9">(4)</a> <a href="#ref-for-idl-long-long-10">(5)</a> <a href="#ref-for-idl-long-long-11">(6)</a> <a href="#ref-for-idl-long-long-12">(7)</a> <a href="#ref-for-idl-long-long-13">(8)</a> <a href="#ref-for-idl-long-long-14">(9)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-unsigned-long-long">
<b><a href="#idl-unsigned-long-long">#idl-unsigned-long-long</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-unsigned-long-long-1">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-unsigned-long-long-2">2.11. Types</a>
<li><a href="#ref-for-idl-unsigned-long-long-3">2.11.10. unsigned long long</a> <a href="#ref-for-idl-unsigned-long-long-4">(2)</a> <a href="#ref-for-idl-unsigned-long-long-5">(3)</a>
<li><a href="#ref-for-idl-unsigned-long-long-6">3.2.11. unsigned long long</a> <a href="#ref-for-idl-unsigned-long-long-7">(2)</a> <a href="#ref-for-idl-unsigned-long-long-8">(3)</a> <a href="#ref-for-idl-unsigned-long-long-9">(4)</a> <a href="#ref-for-idl-unsigned-long-long-10">(5)</a> <a href="#ref-for-idl-unsigned-long-long-11">(6)</a> <a href="#ref-for-idl-unsigned-long-long-12">(7)</a> <a href="#ref-for-idl-unsigned-long-long-13">(8)</a> <a href="#ref-for-idl-unsigned-long-long-14">(9)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-float">
<b><a href="#idl-float">#idl-float</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-float-1">2.2.1. Constants</a> <a href="#ref-for-idl-float-2">(2)</a>
<li><a href="#ref-for-idl-float-3">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-float-4">2.11. Types</a>
<li><a href="#ref-for-idl-float-5">2.11.11. float</a> <a href="#ref-for-idl-float-6">(2)</a> <a href="#ref-for-idl-float-7">(3)</a> <a href="#ref-for-idl-float-8">(4)</a>
<li><a href="#ref-for-idl-float-9">3.2.12. float</a> <a href="#ref-for-idl-float-10">(2)</a> <a href="#ref-for-idl-float-11">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-unrestricted-float">
<b><a href="#idl-unrestricted-float">#idl-unrestricted-float</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-unrestricted-float-1">2.2.1. Constants</a> <a href="#ref-for-idl-unrestricted-float-2">(2)</a> <a href="#ref-for-idl-unrestricted-float-3">(3)</a> <a href="#ref-for-idl-unrestricted-float-4">(4)</a>
<li><a href="#ref-for-idl-unrestricted-float-5">2.11. Types</a>
<li><a href="#ref-for-idl-unrestricted-float-6">2.11.12. unrestricted float</a> <a href="#ref-for-idl-unrestricted-float-7">(2)</a> <a href="#ref-for-idl-unrestricted-float-8">(3)</a>
<li><a href="#ref-for-idl-unrestricted-float-9">3.2.13. unrestricted float</a> <a href="#ref-for-idl-unrestricted-float-10">(2)</a> <a href="#ref-for-idl-unrestricted-float-11">(3)</a> <a href="#ref-for-idl-unrestricted-float-12">(4)</a> <a href="#ref-for-idl-unrestricted-float-13">(5)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-double">
<b><a href="#idl-double">#idl-double</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-double-1">2.2.1. Constants</a> <a href="#ref-for-idl-double-2">(2)</a>
<li><a href="#ref-for-idl-double-3">2.2.4.3. Serializers</a> <a href="#ref-for-idl-double-4">(2)</a> <a href="#ref-for-idl-double-5">(3)</a> <a href="#ref-for-idl-double-6">(4)</a>
<li><a href="#ref-for-idl-double-7">2.2.6. Overloading</a>
<li><a href="#ref-for-idl-double-8">2.11. Types</a>
<li><a href="#ref-for-idl-double-9">2.11.11. float</a> <a href="#ref-for-idl-double-10">(2)</a>
<li><a href="#ref-for-idl-double-11">2.11.13. double</a> <a href="#ref-for-idl-double-12">(2)</a> <a href="#ref-for-idl-double-13">(3)</a>
<li><a href="#ref-for-idl-double-14">3.2.14. double</a> <a href="#ref-for-idl-double-15">(2)</a> <a href="#ref-for-idl-double-16">(3)</a> <a href="#ref-for-idl-double-17">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-unrestricted-double">
<b><a href="#idl-unrestricted-double">#idl-unrestricted-double</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-unrestricted-double-1">2.2.1. Constants</a> <a href="#ref-for-idl-unrestricted-double-2">(2)</a> <a href="#ref-for-idl-unrestricted-double-3">(3)</a> <a href="#ref-for-idl-unrestricted-double-4">(4)</a>
<li><a href="#ref-for-idl-unrestricted-double-5">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-unrestricted-double-6">2.11. Types</a>
<li><a href="#ref-for-idl-unrestricted-double-7">2.11.14. unrestricted double</a> <a href="#ref-for-idl-unrestricted-double-8">(2)</a> <a href="#ref-for-idl-unrestricted-double-9">(3)</a>
<li><a href="#ref-for-idl-unrestricted-double-10">3.2.1. any</a>
<li><a href="#ref-for-idl-unrestricted-double-11">3.2.15. unrestricted double</a> <a href="#ref-for-idl-unrestricted-double-12">(2)</a> <a href="#ref-for-idl-unrestricted-double-13">(3)</a> <a href="#ref-for-idl-unrestricted-double-14">(4)</a> <a href="#ref-for-idl-unrestricted-double-15">(5)</a> <a href="#ref-for-idl-unrestricted-double-16">(6)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-DOMString">
<b><a href="#idl-DOMString">#idl-DOMString</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-DOMString-1">2.2.3. Operations</a>
<li><a href="#ref-for-idl-DOMString-2">2.2.4. Special operations</a> <a href="#ref-for-idl-DOMString-3">(2)</a>
<li><a href="#ref-for-idl-DOMString-4">2.2.4.2. Stringifiers</a> <a href="#ref-for-idl-DOMString-5">(2)</a>
<li><a href="#ref-for-idl-DOMString-6">2.2.4.3. Serializers</a> <a href="#ref-for-idl-DOMString-7">(2)</a> <a href="#ref-for-idl-DOMString-8">(3)</a> <a href="#ref-for-idl-DOMString-9">(4)</a> <a href="#ref-for-idl-DOMString-10">(5)</a> <a href="#ref-for-idl-DOMString-11">(6)</a>
<li><a href="#ref-for-idl-DOMString-12">2.2.4.5. Named properties</a> <a href="#ref-for-idl-DOMString-13">(2)</a>
<li><a href="#ref-for-idl-DOMString-14">2.2.6. Overloading</a> <a href="#ref-for-idl-DOMString-15">(2)</a>
<li><a href="#ref-for-idl-DOMString-16">2.5. Exceptions</a>
<li><a href="#ref-for-idl-DOMString-17">2.6. Enumerations</a>
<li><a href="#ref-for-idl-DOMString-18">2.11. Types</a>
<li><a href="#ref-for-idl-DOMString-19">2.11.15. DOMString</a> <a href="#ref-for-idl-DOMString-20">(2)</a> <a href="#ref-for-idl-DOMString-21">(3)</a> <a href="#ref-for-idl-DOMString-22">(4)</a> <a href="#ref-for-idl-DOMString-23">(5)</a> <a href="#ref-for-idl-DOMString-24">(6)</a> <a href="#ref-for-idl-DOMString-25">(7)</a> <a href="#ref-for-idl-DOMString-26">(8)</a> <a href="#ref-for-idl-DOMString-27">(9)</a> <a href="#ref-for-idl-DOMString-28">(10)</a> <a href="#ref-for-idl-DOMString-29">(11)</a>
<li><a href="#ref-for-idl-DOMString-30">2.11.16. ByteString</a>
<li><a href="#ref-for-idl-DOMString-31">2.11.17. USVString</a> <a href="#ref-for-idl-DOMString-32">(2)</a>
<li><a href="#ref-for-idl-DOMString-33">2.11.21. Enumeration types</a> <a href="#ref-for-idl-DOMString-34">(2)</a>
<li><a href="#ref-for-idl-DOMString-35">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-idl-DOMString-36">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a> <a href="#ref-for-idl-DOMString-37">(2)</a>
<li><a href="#ref-for-idl-DOMString-38">3.2.1. any</a>
<li><a href="#ref-for-idl-DOMString-39">3.2.16. DOMString</a> <a href="#ref-for-idl-DOMString-40">(2)</a> <a href="#ref-for-idl-DOMString-41">(3)</a> <a href="#ref-for-idl-DOMString-42">(4)</a> <a href="#ref-for-idl-DOMString-43">(5)</a>
<li><a href="#ref-for-idl-DOMString-44">3.2.18. USVString</a>
<li><a href="#ref-for-idl-DOMString-45">3.3.19. [TreatNullAs]</a> <a href="#ref-for-idl-DOMString-46">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-obtain-unicode">
<b><a href="#dfn-obtain-unicode">#dfn-obtain-unicode</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-obtain-unicode-1">3.2.18. USVString</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-ByteString">
<b><a href="#idl-ByteString">#idl-ByteString</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-ByteString-1">2.2.3. Operations</a>
<li><a href="#ref-for-idl-ByteString-2">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-ByteString-3">2.11. Types</a>
<li><a href="#ref-for-idl-ByteString-4">2.11.16. ByteString</a> <a href="#ref-for-idl-ByteString-5">(2)</a> <a href="#ref-for-idl-ByteString-6">(3)</a> <a href="#ref-for-idl-ByteString-7">(4)</a> <a href="#ref-for-idl-ByteString-8">(5)</a> <a href="#ref-for-idl-ByteString-9">(6)</a>
<li><a href="#ref-for-idl-ByteString-10">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-idl-ByteString-11">3.2.17. ByteString</a> <a href="#ref-for-idl-ByteString-12">(2)</a> <a href="#ref-for-idl-ByteString-13">(3)</a> <a href="#ref-for-idl-ByteString-14">(4)</a> <a href="#ref-for-idl-ByteString-15">(5)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-USVString">
<b><a href="#idl-USVString">#idl-USVString</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-USVString-1">2.2.3. Operations</a>
<li><a href="#ref-for-idl-USVString-2">2.2.4.2. Stringifiers</a>
<li><a href="#ref-for-idl-USVString-3">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-USVString-4">2.11. Types</a>
<li><a href="#ref-for-idl-USVString-5">2.11.17. USVString</a> <a href="#ref-for-idl-USVString-6">(2)</a> <a href="#ref-for-idl-USVString-7">(3)</a> <a href="#ref-for-idl-USVString-8">(4)</a> <a href="#ref-for-idl-USVString-9">(5)</a>
<li><a href="#ref-for-idl-USVString-10">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-idl-USVString-11">3.2.18. USVString</a> <a href="#ref-for-idl-USVString-12">(2)</a> <a href="#ref-for-idl-USVString-13">(3)</a> <a href="#ref-for-idl-USVString-14">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-object">
<b><a href="#idl-object">#idl-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-object-1">2.11. Types</a>
<li><a href="#ref-for-idl-object-2">2.11.18. object</a> <a href="#ref-for-idl-object-3">(2)</a> <a href="#ref-for-idl-object-4">(3)</a>
<li><a href="#ref-for-idl-object-5">3.2.1. any</a> <a href="#ref-for-idl-object-6">(2)</a> <a href="#ref-for-idl-object-7">(3)</a> <a href="#ref-for-idl-object-8">(4)</a> <a href="#ref-for-idl-object-9">(5)</a>
<li><a href="#ref-for-idl-object-10">3.2.19. object</a> <a href="#ref-for-idl-object-11">(2)</a> <a href="#ref-for-idl-object-12">(3)</a> <a href="#ref-for-idl-object-13">(4)</a> <a href="#ref-for-idl-object-14">(5)</a>
<li><a href="#ref-for-idl-object-15">3.2.28. Union types</a> <a href="#ref-for-idl-object-16">(2)</a> <a href="#ref-for-idl-object-17">(3)</a> <a href="#ref-for-idl-object-18">(4)</a> <a href="#ref-for-idl-object-19">(5)</a> <a href="#ref-for-idl-object-20">(6)</a> <a href="#ref-for-idl-object-21">(7)</a> <a href="#ref-for-idl-object-22">(8)</a> <a href="#ref-for-idl-object-23">(9)</a> <a href="#ref-for-idl-object-24">(10)</a>
<li><a href="#ref-for-idl-object-25">3.3.16. [SameObject]</a>
<li><a href="#ref-for-idl-object-26">3.5. Overload resolution algorithm</a> <a href="#ref-for-idl-object-27">(2)</a> <a href="#ref-for-idl-object-28">(3)</a> <a href="#ref-for-idl-object-29">(4)</a> <a href="#ref-for-idl-object-30">(5)</a> <a href="#ref-for-idl-object-31">(6)</a> <a href="#ref-for-idl-object-32">(7)</a> <a href="#ref-for-idl-object-33">(8)</a> <a href="#ref-for-idl-object-34">(9)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-interface">
<b><a href="#idl-interface">#idl-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-interface-1">2.2.4.3. Serializers</a>
<li><a href="#ref-for-idl-interface-2">2.11. Types</a>
<li><a href="#ref-for-idl-interface-3">2.11.22. Callback function types</a>
<li><a href="#ref-for-idl-interface-4">3.2.20. Interface types</a> <a href="#ref-for-idl-interface-5">(2)</a> <a href="#ref-for-idl-interface-6">(3)</a> <a href="#ref-for-idl-interface-7">(4)</a> <a href="#ref-for-idl-interface-8">(5)</a> <a href="#ref-for-idl-interface-9">(6)</a>
<li><a href="#ref-for-idl-interface-10">3.2.28. Union types</a>
<li><a href="#ref-for-idl-interface-11">3.3.11. [NewObject]</a>
<li><a href="#ref-for-idl-interface-12">3.3.14. [PutForwards]</a> <a href="#ref-for-idl-interface-13">(2)</a>
<li><a href="#ref-for-idl-interface-14">3.3.16. [SameObject]</a>
<li><a href="#ref-for-idl-interface-15">3.5. Overload resolution algorithm</a>
<li><a href="#ref-for-idl-interface-16">3.6.1.1. Interface object [[Call]] method</a>
<li><a href="#ref-for-idl-interface-17">3.6.2. Named constructors</a>
<li><a href="#ref-for-idl-interface-18">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-idl-interface-19">(2)</a> <a href="#ref-for-idl-interface-20">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-callback-context">
<b><a href="#dfn-callback-context">#dfn-callback-context</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-callback-context-1">2.11.19. Interface types</a> <a href="#ref-for-dfn-callback-context-2">(2)</a>
<li><a href="#ref-for-dfn-callback-context-3">2.11.22. Callback function types</a> <a href="#ref-for-dfn-callback-context-4">(2)</a>
<li><a href="#ref-for-dfn-callback-context-5">3.2.20. Interface types</a>
<li><a href="#ref-for-dfn-callback-context-6">3.2.23. Callback function types</a>
<li><a href="#ref-for-dfn-callback-context-7">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-callback-context-8">(2)</a> <a href="#ref-for-dfn-callback-context-9">(3)</a>
<li><a href="#ref-for-dfn-callback-context-10">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-dictionary">
<b><a href="#idl-dictionary">#idl-dictionary</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-dictionary-1">2.2.2. Attributes</a>
<li><a href="#ref-for-idl-dictionary-2">2.2.3. Operations</a>
<li><a href="#ref-for-idl-dictionary-3">2.2.6. Overloading</a>
<li><a href="#ref-for-idl-dictionary-4">2.11.25. Open dictionary types — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-idl-dictionary-5">2.11.27. Union types</a>
<li><a href="#ref-for-idl-dictionary-6">3.2.21. Dictionary types</a> <a href="#ref-for-idl-dictionary-7">(2)</a>
<li><a href="#ref-for-idl-dictionary-8">3.2.28. Union types</a> <a href="#ref-for-idl-dictionary-9">(2)</a>
<li><a href="#ref-for-idl-dictionary-10">3.5. Overload resolution algorithm</a> <a href="#ref-for-idl-dictionary-11">(2)</a> <a href="#ref-for-idl-dictionary-12">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-enumeration">
<b><a href="#idl-enumeration">#idl-enumeration</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-enumeration-1">2.11. Types</a>
<li><a href="#ref-for-idl-enumeration-2">3.2.22. Enumeration types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-callback-function">
<b><a href="#idl-callback-function">#idl-callback-function</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-callback-function-1">3.2.23. Callback function types</a> <a href="#ref-for-idl-callback-function-2">(2)</a> <a href="#ref-for-idl-callback-function-3">(3)</a> <a href="#ref-for-idl-callback-function-4">(4)</a> <a href="#ref-for-idl-callback-function-5">(5)</a>
<li><a href="#ref-for-idl-callback-function-6">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-nullable-type">
<b><a href="#dfn-nullable-type">#dfn-nullable-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-nullable-type-1">2.2.1. Constants</a> <a href="#ref-for-dfn-nullable-type-2">(2)</a> <a href="#ref-for-dfn-nullable-type-3">(3)</a>
<li><a href="#ref-for-dfn-nullable-type-4">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-nullable-type-5">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-nullable-type-6">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-nullable-type-7">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-nullable-type-8">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-nullable-type-9">2.11.15. DOMString</a>
<li><a href="#ref-for-dfn-nullable-type-10">2.11.18. object</a>
<li><a href="#ref-for-dfn-nullable-type-11">2.11.19. Interface types</a>
<li><a href="#ref-for-dfn-nullable-type-12">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-nullable-type-13">2.11.27. Union types</a> <a href="#ref-for-dfn-nullable-type-14">(2)</a> <a href="#ref-for-dfn-nullable-type-15">(3)</a>
<li><a href="#ref-for-dfn-nullable-type-16">3.2.23. Callback function types</a>
<li><a href="#ref-for-dfn-nullable-type-17">3.2.24. Nullable types — T?</a> <a href="#ref-for-dfn-nullable-type-18">(2)</a> <a href="#ref-for-dfn-nullable-type-19">(3)</a> <a href="#ref-for-dfn-nullable-type-20">(4)</a> <a href="#ref-for-dfn-nullable-type-21">(5)</a> <a href="#ref-for-dfn-nullable-type-22">(6)</a> <a href="#ref-for-dfn-nullable-type-23">(7)</a> <a href="#ref-for-dfn-nullable-type-24">(8)</a>
<li><a href="#ref-for-dfn-nullable-type-25">3.3.18. [TreatNonObjectAsNull]</a>
<li><a href="#ref-for-dfn-nullable-type-26">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-nullable-type-27">(2)</a> <a href="#ref-for-dfn-nullable-type-28">(3)</a> <a href="#ref-for-dfn-nullable-type-29">(4)</a> <a href="#ref-for-dfn-nullable-type-30">(5)</a> <a href="#ref-for-dfn-nullable-type-31">(6)</a> <a href="#ref-for-dfn-nullable-type-32">(7)</a> <a href="#ref-for-dfn-nullable-type-33">(8)</a> <a href="#ref-for-dfn-nullable-type-34">(9)</a> <a href="#ref-for-dfn-nullable-type-35">(10)</a> <a href="#ref-for-dfn-nullable-type-36">(11)</a> <a href="#ref-for-dfn-nullable-type-37">(12)</a> <a href="#ref-for-dfn-nullable-type-38">(13)</a> <a href="#ref-for-dfn-nullable-type-39">(14)</a> <a href="#ref-for-dfn-nullable-type-40">(15)</a> <a href="#ref-for-dfn-nullable-type-41">(16)</a> <a href="#ref-for-dfn-nullable-type-42">(17)</a> <a href="#ref-for-dfn-nullable-type-43">(18)</a> <a href="#ref-for-dfn-nullable-type-44">(19)</a> <a href="#ref-for-dfn-nullable-type-45">(20)</a> <a href="#ref-for-dfn-nullable-type-46">(21)</a> <a href="#ref-for-dfn-nullable-type-47">(22)</a> <a href="#ref-for-dfn-nullable-type-48">(23)</a> <a href="#ref-for-dfn-nullable-type-49">(24)</a> <a href="#ref-for-dfn-nullable-type-50">(25)</a> <a href="#ref-for-dfn-nullable-type-51">(26)</a> <a href="#ref-for-dfn-nullable-type-52">(27)</a> <a href="#ref-for-dfn-nullable-type-53">(28)</a> <a href="#ref-for-dfn-nullable-type-54">(29)</a> <a href="#ref-for-dfn-nullable-type-55">(30)</a> <a href="#ref-for-dfn-nullable-type-56">(31)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-inner-type">
<b><a href="#dfn-inner-type">#dfn-inner-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-inner-type-1">2.2.1. Constants</a>
<li><a href="#ref-for-dfn-inner-type-2">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-inner-type-3">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-inner-type-4">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-inner-type-5">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-inner-type-6">2.11.27. Union types</a> <a href="#ref-for-dfn-inner-type-7">(2)</a>
<li><a href="#ref-for-dfn-inner-type-8">3.2.24. Nullable types — T?</a> <a href="#ref-for-dfn-inner-type-9">(2)</a> <a href="#ref-for-dfn-inner-type-10">(3)</a> <a href="#ref-for-dfn-inner-type-11">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="sequence-type">
<b><a href="#sequence-type">#sequence-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-sequence-type-1">2.2.2. Attributes</a>
<li><a href="#ref-for-sequence-type-2">2.2.3. Operations</a>
<li><a href="#ref-for-sequence-type-3">2.2.4.3. Serializers</a>
<li><a href="#ref-for-sequence-type-4">2.4. Dictionaries</a>
<li><a href="#ref-for-sequence-type-5">2.8. Typedefs</a>
<li><a href="#ref-for-sequence-type-6">2.11.15. DOMString</a>
<li><a href="#ref-for-sequence-type-7">2.11.16. ByteString</a>
<li><a href="#ref-for-sequence-type-8">2.11.24. Sequence types — sequence<T></a>
<li><a href="#ref-for-sequence-type-9">2.11.32. Frozen array types — FrozenArray<T></a>
<li><a href="#ref-for-sequence-type-10">3.2.25. Sequences — sequence<T></a> <a href="#ref-for-sequence-type-11">(2)</a> <a href="#ref-for-sequence-type-12">(3)</a>
<li><a href="#ref-for-sequence-type-13">3.2.25.1. Creating a sequence from an iterable</a> <a href="#ref-for-sequence-type-14">(2)</a>
<li><a href="#ref-for-sequence-type-15">3.2.28. Union types</a>
<li><a href="#ref-for-sequence-type-16">3.2.33. Frozen arrays — FrozenArray<T></a>
<li><a href="#ref-for-sequence-type-17">3.2.33.1. Creating a frozen array from an iterable</a>
<li><a href="#ref-for-sequence-type-18">3.5. Overload resolution algorithm</a> <a href="#ref-for-sequence-type-19">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-open-dictionary">
<b><a href="#idl-open-dictionary">#idl-open-dictionary</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-open-dictionary-1">3.2.26. Open dictionaries — OpenDictionary<[K,] V></a> <a href="#ref-for-idl-open-dictionary-2">(2)</a> <a href="#ref-for-idl-open-dictionary-3">(3)</a> <a href="#ref-for-idl-open-dictionary-4">(4)</a> <a href="#ref-for-idl-open-dictionary-5">(5)</a> <a href="#ref-for-idl-open-dictionary-6">(6)</a> <a href="#ref-for-idl-open-dictionary-7">(7)</a> <a href="#ref-for-idl-open-dictionary-8">(8)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="opendictionary-mappings">
<b><a href="#opendictionary-mappings">#opendictionary-mappings</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-opendictionary-mappings-1">3.2.26. Open dictionaries — OpenDictionary<[K,] V></a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-promise">
<b><a href="#idl-promise">#idl-promise</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-promise-1">3.2.27. Promise types — Promise<T></a> <a href="#ref-for-idl-promise-2">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-promise-type">
<b><a href="#dfn-promise-type">#dfn-promise-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-promise-type-1">2.2.4.1. Legacy callers</a>
<li><a href="#ref-for-dfn-promise-type-2">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-promise-type-3">3.2.27. Promise types — Promise<T></a> <a href="#ref-for-dfn-promise-type-4">(2)</a> <a href="#ref-for-dfn-promise-type-5">(3)</a> <a href="#ref-for-dfn-promise-type-6">(4)</a>
<li><a href="#ref-for-dfn-promise-type-7">3.3.11. [NewObject]</a>
<li><a href="#ref-for-dfn-promise-type-8">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-promise-type-9">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-promise-type-10">(2)</a>
<li><a href="#ref-for-dfn-promise-type-11">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-union-type">
<b><a href="#dfn-union-type">#dfn-union-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-union-type-1">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-union-type-2">2.2.3. Operations</a> <a href="#ref-for-dfn-union-type-3">(2)</a>
<li><a href="#ref-for-dfn-union-type-4">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-union-type-5">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-union-type-6">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-union-type-7">2.11.1. any</a> <a href="#ref-for-dfn-union-type-8">(2)</a>
<li><a href="#ref-for-dfn-union-type-9">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-union-type-10">2.11.27. Union types</a> <a href="#ref-for-dfn-union-type-11">(2)</a> <a href="#ref-for-dfn-union-type-12">(3)</a> <a href="#ref-for-dfn-union-type-13">(4)</a> <a href="#ref-for-dfn-union-type-14">(5)</a> <a href="#ref-for-dfn-union-type-15">(6)</a> <a href="#ref-for-dfn-union-type-16">(7)</a> <a href="#ref-for-dfn-union-type-17">(8)</a> <a href="#ref-for-dfn-union-type-18">(9)</a> <a href="#ref-for-dfn-union-type-19">(10)</a> <a href="#ref-for-dfn-union-type-20">(11)</a> <a href="#ref-for-dfn-union-type-21">(12)</a> <a href="#ref-for-dfn-union-type-22">(13)</a>
<li><a href="#ref-for-dfn-union-type-23">3.2.28. Union types</a> <a href="#ref-for-dfn-union-type-24">(2)</a> <a href="#ref-for-dfn-union-type-25">(3)</a> <a href="#ref-for-dfn-union-type-26">(4)</a>
<li><a href="#ref-for-dfn-union-type-27">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-union-type-28">(2)</a> <a href="#ref-for-dfn-union-type-29">(3)</a> <a href="#ref-for-dfn-union-type-30">(4)</a> <a href="#ref-for-dfn-union-type-31">(5)</a> <a href="#ref-for-dfn-union-type-32">(6)</a> <a href="#ref-for-dfn-union-type-33">(7)</a> <a href="#ref-for-dfn-union-type-34">(8)</a> <a href="#ref-for-dfn-union-type-35">(9)</a> <a href="#ref-for-dfn-union-type-36">(10)</a> <a href="#ref-for-dfn-union-type-37">(11)</a> <a href="#ref-for-dfn-union-type-38">(12)</a> <a href="#ref-for-dfn-union-type-39">(13)</a> <a href="#ref-for-dfn-union-type-40">(14)</a> <a href="#ref-for-dfn-union-type-41">(15)</a> <a href="#ref-for-dfn-union-type-42">(16)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-union-member-type">
<b><a href="#dfn-union-member-type">#dfn-union-member-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-union-member-type-1">2.2.4.3. Serializers</a>
<li><a href="#ref-for-dfn-union-member-type-2">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-union-member-type-3">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-union-member-type-4">2.11.27. Union types</a> <a href="#ref-for-dfn-union-member-type-5">(2)</a> <a href="#ref-for-dfn-union-member-type-6">(3)</a> <a href="#ref-for-dfn-union-member-type-7">(4)</a> <a href="#ref-for-dfn-union-member-type-8">(5)</a> <a href="#ref-for-dfn-union-member-type-9">(6)</a>
<li><a href="#ref-for-dfn-union-member-type-10">3.2.28. Union types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-flattened-union-member-types">
<b><a href="#dfn-flattened-union-member-types">#dfn-flattened-union-member-types</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-flattened-union-member-types-1">2.2.2. Attributes</a>
<li><a href="#ref-for-dfn-flattened-union-member-types-2">2.2.3. Operations</a> <a href="#ref-for-dfn-flattened-union-member-types-3">(2)</a>
<li><a href="#ref-for-dfn-flattened-union-member-types-4">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-flattened-union-member-types-5">2.11.27. Union types</a> <a href="#ref-for-dfn-flattened-union-member-types-6">(2)</a> <a href="#ref-for-dfn-flattened-union-member-types-7">(3)</a> <a href="#ref-for-dfn-flattened-union-member-types-8">(4)</a>
<li><a href="#ref-for-dfn-flattened-union-member-types-9">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-flattened-union-member-types-10">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-flattened-union-member-types-11">(2)</a> <a href="#ref-for-dfn-flattened-union-member-types-12">(3)</a> <a href="#ref-for-dfn-flattened-union-member-types-13">(4)</a> <a href="#ref-for-dfn-flattened-union-member-types-14">(5)</a> <a href="#ref-for-dfn-flattened-union-member-types-15">(6)</a> <a href="#ref-for-dfn-flattened-union-member-types-16">(7)</a> <a href="#ref-for-dfn-flattened-union-member-types-17">(8)</a> <a href="#ref-for-dfn-flattened-union-member-types-18">(9)</a> <a href="#ref-for-dfn-flattened-union-member-types-19">(10)</a> <a href="#ref-for-dfn-flattened-union-member-types-20">(11)</a> <a href="#ref-for-dfn-flattened-union-member-types-21">(12)</a> <a href="#ref-for-dfn-flattened-union-member-types-22">(13)</a> <a href="#ref-for-dfn-flattened-union-member-types-23">(14)</a> <a href="#ref-for-dfn-flattened-union-member-types-24">(15)</a> <a href="#ref-for-dfn-flattened-union-member-types-25">(16)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-number-of-nullable-member-types">
<b><a href="#dfn-number-of-nullable-member-types">#dfn-number-of-nullable-member-types</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-number-of-nullable-member-types-1">2.11.27. Union types</a> <a href="#ref-for-dfn-number-of-nullable-member-types-2">(2)</a> <a href="#ref-for-dfn-number-of-nullable-member-types-3">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-includes-a-nullable-type">
<b><a href="#dfn-includes-a-nullable-type">#dfn-includes-a-nullable-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-includes-a-nullable-type-1">2.2.6. Overloading</a>
<li><a href="#ref-for-dfn-includes-a-nullable-type-2">2.11.23. Nullable types — T?</a>
<li><a href="#ref-for-dfn-includes-a-nullable-type-3">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-includes-a-nullable-type-4">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-RegExp">
<b><a href="#idl-RegExp">#idl-RegExp</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-RegExp-1">2.11.28. RegExp</a> <a href="#ref-for-idl-RegExp-2">(2)</a> <a href="#ref-for-idl-RegExp-3">(3)</a>
<li><a href="#ref-for-idl-RegExp-4">3.2.28. Union types</a> <a href="#ref-for-idl-RegExp-5">(2)</a>
<li><a href="#ref-for-idl-RegExp-6">3.2.29. RegExp</a> <a href="#ref-for-idl-RegExp-7">(2)</a> <a href="#ref-for-idl-RegExp-8">(3)</a> <a href="#ref-for-idl-RegExp-9">(4)</a> <a href="#ref-for-idl-RegExp-10">(5)</a>
<li><a href="#ref-for-idl-RegExp-11">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Error">
<b><a href="#idl-Error">#idl-Error</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Error-1">2.5. Exceptions</a> <a href="#ref-for-idl-Error-2">(2)</a>
<li><a href="#ref-for-idl-Error-3">2.11. Types</a>
<li><a href="#ref-for-idl-Error-4">2.11.29. Error</a> <a href="#ref-for-idl-Error-5">(2)</a> <a href="#ref-for-idl-Error-6">(3)</a>
<li><a href="#ref-for-idl-Error-7">3.2.28. Union types</a> <a href="#ref-for-idl-Error-8">(2)</a> <a href="#ref-for-idl-Error-9">(3)</a>
<li><a href="#ref-for-idl-Error-10">3.2.30. Error</a> <a href="#ref-for-idl-Error-11">(2)</a> <a href="#ref-for-idl-Error-12">(3)</a> <a href="#ref-for-idl-Error-13">(4)</a> <a href="#ref-for-idl-Error-14">(5)</a>
<li><a href="#ref-for-idl-Error-15">3.5. Overload resolution algorithm</a> <a href="#ref-for-idl-Error-16">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-ArrayBuffer">
<b><a href="#idl-ArrayBuffer">#idl-ArrayBuffer</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-ArrayBuffer-1">2.11. Types</a>
<li><a href="#ref-for-idl-ArrayBuffer-2">2.11.31. Buffer source types</a> <a href="#ref-for-idl-ArrayBuffer-3">(2)</a> <a href="#ref-for-idl-ArrayBuffer-4">(3)</a> <a href="#ref-for-idl-ArrayBuffer-5">(4)</a> <a href="#ref-for-idl-ArrayBuffer-6">(5)</a> <a href="#ref-for-idl-ArrayBuffer-7">(6)</a> <a href="#ref-for-idl-ArrayBuffer-8">(7)</a> <a href="#ref-for-idl-ArrayBuffer-9">(8)</a> <a href="#ref-for-idl-ArrayBuffer-10">(9)</a>
<li><a href="#ref-for-idl-ArrayBuffer-11">3.2.28. Union types</a> <a href="#ref-for-idl-ArrayBuffer-12">(2)</a>
<li><a href="#ref-for-idl-ArrayBuffer-13">3.2.32. Buffer source types</a> <a href="#ref-for-idl-ArrayBuffer-14">(2)</a> <a href="#ref-for-idl-ArrayBuffer-15">(3)</a> <a href="#ref-for-idl-ArrayBuffer-16">(4)</a>
<li><a href="#ref-for-idl-ArrayBuffer-17">3.5. Overload resolution algorithm</a>
<li><a href="#ref-for-idl-ArrayBuffer-18">4.1. ArrayBufferView</a>
<li><a href="#ref-for-idl-ArrayBuffer-19">4.2. BufferSource</a> <a href="#ref-for-idl-ArrayBuffer-20">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-DataView">
<b><a href="#idl-DataView">#idl-DataView</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-DataView-1">2.11. Types</a>
<li><a href="#ref-for-idl-DataView-2">3.2.28. Union types</a> <a href="#ref-for-idl-DataView-3">(2)</a>
<li><a href="#ref-for-idl-DataView-4">3.2.32. Buffer source types</a> <a href="#ref-for-idl-DataView-5">(2)</a>
<li><a href="#ref-for-idl-DataView-6">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Int8Array">
<b><a href="#idl-Int8Array">#idl-Int8Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Int8Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Int8Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Int16Array">
<b><a href="#idl-Int16Array">#idl-Int16Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Int16Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Int16Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Int32Array">
<b><a href="#idl-Int32Array">#idl-Int32Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Int32Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Int32Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Uint8Array">
<b><a href="#idl-Uint8Array">#idl-Uint8Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Uint8Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Uint8Array-2">2.11.31. Buffer source types</a>
<li><a href="#ref-for-idl-Uint8Array-3">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Uint16Array">
<b><a href="#idl-Uint16Array">#idl-Uint16Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Uint16Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Uint16Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Uint32Array">
<b><a href="#idl-Uint32Array">#idl-Uint32Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Uint32Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Uint32Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Uint8ClampedArray">
<b><a href="#idl-Uint8ClampedArray">#idl-Uint8ClampedArray</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Uint8ClampedArray-1">2.11. Types</a>
<li><a href="#ref-for-idl-Uint8ClampedArray-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Float32Array">
<b><a href="#idl-Float32Array">#idl-Float32Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Float32Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Float32Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-Float64Array">
<b><a href="#idl-Float64Array">#idl-Float64Array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-Float64Array-1">2.11. Types</a>
<li><a href="#ref-for-idl-Float64Array-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-detach">
<b><a href="#dfn-detach">#dfn-detach</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-detach-1">2.11.31. Buffer source types</a>
<li><a href="#ref-for-dfn-detach-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-get-buffer-source-reference">
<b><a href="#dfn-get-buffer-source-reference">#dfn-get-buffer-source-reference</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-get-buffer-source-reference-1">2.11.31. Buffer source types</a>
<li><a href="#ref-for-dfn-get-buffer-source-reference-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-get-buffer-source-copy">
<b><a href="#dfn-get-buffer-source-copy">#dfn-get-buffer-source-copy</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-get-buffer-source-copy-1">2.11.31. Buffer source types</a>
<li><a href="#ref-for-dfn-get-buffer-source-copy-2">3.2.32. Buffer source types</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="idl-frozen-array">
<b><a href="#idl-frozen-array">#idl-frozen-array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-idl-frozen-array-1">2.11.32. Frozen array types — FrozenArray<T></a>
<li><a href="#ref-for-idl-frozen-array-2">3.2.33. Frozen arrays — FrozenArray<T></a> <a href="#ref-for-idl-frozen-array-3">(2)</a> <a href="#ref-for-idl-frozen-array-4">(3)</a>
<li><a href="#ref-for-idl-frozen-array-5">3.2.33.1. Creating a frozen array from an iterable</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-frozen-array-type">
<b><a href="#dfn-frozen-array-type">#dfn-frozen-array-type</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-frozen-array-type-1">2.4. Dictionaries</a>
<li><a href="#ref-for-dfn-frozen-array-type-2">2.11.16. ByteString</a>
<li><a href="#ref-for-dfn-frozen-array-type-3">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-frozen-array-type-4">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-frozen-array-type-5">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-extended-attribute">
<b><a href="#dfn-extended-attribute">#dfn-extended-attribute</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-extended-attribute-1">2. Interface definition language</a> <a href="#ref-for-dfn-extended-attribute-2">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-3">2.2. Interfaces</a> <a href="#ref-for-dfn-extended-attribute-4">(2)</a> <a href="#ref-for-dfn-extended-attribute-5">(3)</a> <a href="#ref-for-dfn-extended-attribute-6">(4)</a>
<li><a href="#ref-for-dfn-extended-attribute-7">2.2.2. Attributes</a> <a href="#ref-for-dfn-extended-attribute-8">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-9">2.2.3. Operations</a> <a href="#ref-for-dfn-extended-attribute-10">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-11">2.2.6. Overloading</a> <a href="#ref-for-dfn-extended-attribute-12">(2)</a> <a href="#ref-for-dfn-extended-attribute-13">(3)</a> <a href="#ref-for-dfn-extended-attribute-14">(4)</a> <a href="#ref-for-dfn-extended-attribute-15">(5)</a>
<li><a href="#ref-for-dfn-extended-attribute-16">2.2.8. Maplike declarations</a>
<li><a href="#ref-for-dfn-extended-attribute-17">2.2.9. Setlike declarations</a>
<li><a href="#ref-for-dfn-extended-attribute-18">2.6. Enumerations</a>
<li><a href="#ref-for-dfn-extended-attribute-19">2.8. Typedefs</a>
<li><a href="#ref-for-dfn-extended-attribute-20">2.9. Implements statements</a>
<li><a href="#ref-for-dfn-extended-attribute-21">2.12. Extended attributes</a>
<li><a href="#ref-for-dfn-extended-attribute-22">3.2.4. byte</a> <a href="#ref-for-dfn-extended-attribute-23">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-24">3.2.5. octet</a> <a href="#ref-for-dfn-extended-attribute-25">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-26">3.2.6. short</a> <a href="#ref-for-dfn-extended-attribute-27">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-28">3.2.7. unsigned short</a> <a href="#ref-for-dfn-extended-attribute-29">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-30">3.2.8. long</a> <a href="#ref-for-dfn-extended-attribute-31">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-32">3.2.9. unsigned long</a> <a href="#ref-for-dfn-extended-attribute-33">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-34">3.2.10. long long</a> <a href="#ref-for-dfn-extended-attribute-35">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-36">3.2.11. unsigned long long</a> <a href="#ref-for-dfn-extended-attribute-37">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-38">3.3. ECMAScript-specific extended attributes</a>
<li><a href="#ref-for-dfn-extended-attribute-39">3.3.1. [Clamp]</a> <a href="#ref-for-dfn-extended-attribute-40">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-41">3.3.2. [Constructor]</a>
<li><a href="#ref-for-dfn-extended-attribute-42">3.3.3. [EnforceRange]</a> <a href="#ref-for-dfn-extended-attribute-43">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-44">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-extended-attribute-45">(2)</a> <a href="#ref-for-dfn-extended-attribute-46">(3)</a> <a href="#ref-for-dfn-extended-attribute-47">(4)</a> <a href="#ref-for-dfn-extended-attribute-48">(5)</a>
<li><a href="#ref-for-dfn-extended-attribute-49">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-dfn-extended-attribute-50">(2)</a> <a href="#ref-for-dfn-extended-attribute-51">(3)</a> <a href="#ref-for-dfn-extended-attribute-52">(4)</a> <a href="#ref-for-dfn-extended-attribute-53">(5)</a> <a href="#ref-for-dfn-extended-attribute-54">(6)</a> <a href="#ref-for-dfn-extended-attribute-55">(7)</a> <a href="#ref-for-dfn-extended-attribute-56">(8)</a>
<li><a href="#ref-for-dfn-extended-attribute-57">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-extended-attribute-58">3.3.7. [LegacyUnenumerableNamedProperties]</a>
<li><a href="#ref-for-dfn-extended-attribute-59">3.3.8. [LenientSetter]</a>
<li><a href="#ref-for-dfn-extended-attribute-60">3.3.9. [LenientThis]</a>
<li><a href="#ref-for-dfn-extended-attribute-61">3.3.10. [NamedConstructor]</a>
<li><a href="#ref-for-dfn-extended-attribute-62">3.3.11. [NewObject]</a>
<li><a href="#ref-for-dfn-extended-attribute-63">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-extended-attribute-64">3.3.13. [OverrideBuiltins]</a>
<li><a href="#ref-for-dfn-extended-attribute-65">3.3.14. [PutForwards]</a> <a href="#ref-for-dfn-extended-attribute-66">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-67">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-extended-attribute-68">3.3.16. [SameObject]</a>
<li><a href="#ref-for-dfn-extended-attribute-69">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-extended-attribute-70">(2)</a> <a href="#ref-for-dfn-extended-attribute-71">(3)</a> <a href="#ref-for-dfn-extended-attribute-72">(4)</a>
<li><a href="#ref-for-dfn-extended-attribute-73">3.3.18. [TreatNonObjectAsNull]</a> <a href="#ref-for-dfn-extended-attribute-74">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-75">3.3.19. [TreatNullAs]</a>
<li><a href="#ref-for-dfn-extended-attribute-76">3.3.20. [Unforgeable]</a> <a href="#ref-for-dfn-extended-attribute-77">(2)</a> <a href="#ref-for-dfn-extended-attribute-78">(3)</a> <a href="#ref-for-dfn-extended-attribute-79">(4)</a> <a href="#ref-for-dfn-extended-attribute-80">(5)</a>
<li><a href="#ref-for-dfn-extended-attribute-81">3.3.21. [Unscopable]</a>
<li><a href="#ref-for-dfn-extended-attribute-82">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-extended-attribute-83">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-84">3.6. Interfaces</a>
<li><a href="#ref-for-dfn-extended-attribute-85">3.6.1.1. Interface object [[Call]] method</a> <a href="#ref-for-dfn-extended-attribute-86">(2)</a> <a href="#ref-for-dfn-extended-attribute-87">(3)</a>
<li><a href="#ref-for-dfn-extended-attribute-88">3.6.2. Named constructors</a> <a href="#ref-for-dfn-extended-attribute-89">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-90">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-extended-attribute-91">(2)</a> <a href="#ref-for-dfn-extended-attribute-92">(3)</a> <a href="#ref-for-dfn-extended-attribute-93">(4)</a>
<li><a href="#ref-for-dfn-extended-attribute-94">3.6.4. Named properties object</a>
<li><a href="#ref-for-dfn-extended-attribute-95">3.6.4.1. Named properties object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-extended-attribute-96">3.6.6. Attributes</a> <a href="#ref-for-dfn-extended-attribute-97">(2)</a> <a href="#ref-for-dfn-extended-attribute-98">(3)</a>
<li><a href="#ref-for-dfn-extended-attribute-99">3.8.1. Indexed and named properties</a> <a href="#ref-for-dfn-extended-attribute-100">(2)</a> <a href="#ref-for-dfn-extended-attribute-101">(3)</a>
<li><a href="#ref-for-dfn-extended-attribute-102">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a> <a href="#ref-for-dfn-extended-attribute-103">(2)</a>
<li><a href="#ref-for-dfn-extended-attribute-104">3.8.7. Platform object [[DefineOwnProperty]] method</a> <a href="#ref-for-dfn-extended-attribute-105">(2)</a> <a href="#ref-for-dfn-extended-attribute-106">(3)</a>
<li><a href="#ref-for-dfn-extended-attribute-107">3.8.8. Platform object [[Delete]] method</a>
<li><a href="#ref-for-dfn-extended-attribute-108">3.8.10. Property enumeration</a>
<li><a href="#ref-for-dfn-extended-attribute-109">5. Extensibility</a>
<li><a href="#ref-for-dfn-extended-attribute-110">IDL grammar</a> <a href="#ref-for-dfn-extended-attribute-111">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-xattr-no-arguments">
<b><a href="#dfn-xattr-no-arguments">#dfn-xattr-no-arguments</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-xattr-no-arguments-1">3.3.1. [Clamp]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-2">3.3.2. [Constructor]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-3">3.3.3. [EnforceRange]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-4">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-5">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-6">3.3.7. [LegacyUnenumerableNamedProperties]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-7">3.3.8. [LenientSetter]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-8">3.3.9. [LenientThis]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-9">3.3.11. [NewObject]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-10">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-11">3.3.13. [OverrideBuiltins]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-12">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-13">3.3.16. [SameObject]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-14">3.3.17. [SecureContext]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-15">3.3.20. [Unforgeable]</a>
<li><a href="#ref-for-dfn-xattr-no-arguments-16">3.3.21. [Unscopable]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-xattr-argument-list">
<b><a href="#dfn-xattr-argument-list">#dfn-xattr-argument-list</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-xattr-argument-list-1">2.2.3. Operations</a>
<li><a href="#ref-for-dfn-xattr-argument-list-2">3.3.2. [Constructor]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-xattr-named-argument-list">
<b><a href="#dfn-xattr-named-argument-list">#dfn-xattr-named-argument-list</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-xattr-named-argument-list-1">2.2.6. Overloading</a> <a href="#ref-for-dfn-xattr-named-argument-list-2">(2)</a>
<li><a href="#ref-for-dfn-xattr-named-argument-list-3">3.3.10. [NamedConstructor]</a>
<li><a href="#ref-for-dfn-xattr-named-argument-list-4">3.6.2. Named constructors</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-xattr-identifier">
<b><a href="#dfn-xattr-identifier">#dfn-xattr-identifier</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-xattr-identifier-1">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-xattr-identifier-2">3.3.10. [NamedConstructor]</a>
<li><a href="#ref-for-dfn-xattr-identifier-3">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-dfn-xattr-identifier-4">3.3.19. [TreatNullAs]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-xattr-identifier-list">
<b><a href="#dfn-xattr-identifier-list">#dfn-xattr-identifier-list</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-xattr-identifier-list-1">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-xattr-identifier-list-2">3.3.5. [Global] and [PrimaryGlobal]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-class-string">
<b><a href="#dfn-class-string">#dfn-class-string</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-class-string-1">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-class-string-2">3.6.4. Named properties object</a>
<li><a href="#ref-for-dfn-class-string-3">3.6.9.4. Default iterator objects</a>
<li><a href="#ref-for-dfn-class-string-4">3.6.9.5. Iterator prototype object</a>
<li><a href="#ref-for-dfn-class-string-5">3.8. Platform objects implementing interfaces</a>
<li><a href="#ref-for-dfn-class-string-6">3.12.2. DOMException prototype object</a>
<li><a href="#ref-for-dfn-class-string-7">3.13. Exception objects</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-function-object">
<b><a href="#dfn-function-object">#dfn-function-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-function-object-1">3.2.27. Promise types — Promise<T></a> <a href="#ref-for-dfn-function-object-2">(2)</a>
<li><a href="#ref-for-dfn-function-object-3">3.6.1. Interface object</a> <a href="#ref-for-dfn-function-object-4">(2)</a> <a href="#ref-for-dfn-function-object-5">(3)</a>
<li><a href="#ref-for-dfn-function-object-6">3.6.2. Named constructors</a>
<li><a href="#ref-for-dfn-function-object-7">3.6.8.1. @@iterator</a>
<li><a href="#ref-for-dfn-function-object-8">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-function-object-9">3.6.9.1. entries</a>
<li><a href="#ref-for-dfn-function-object-10">3.6.9.2. keys</a>
<li><a href="#ref-for-dfn-function-object-11">3.6.9.3. values</a>
<li><a href="#ref-for-dfn-function-object-12">3.6.9.5. Iterator prototype object</a>
<li><a href="#ref-for-dfn-function-object-13">3.6.10. Maplike declarations</a>
<li><a href="#ref-for-dfn-function-object-14">3.6.10.2. entries</a>
<li><a href="#ref-for-dfn-function-object-15">3.6.11. Setlike declarations</a>
<li><a href="#ref-for-dfn-function-object-16">3.6.11.2. values</a>
<li><a href="#ref-for-dfn-function-object-17">3.12.1. DOMException constructor object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="ecmascript-throw">
<b><a href="#ecmascript-throw">#ecmascript-throw</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-ecmascript-throw-1">3.2.4. byte</a> <a href="#ref-for-ecmascript-throw-2">(2)</a>
<li><a href="#ref-for-ecmascript-throw-3">3.2.5. octet</a> <a href="#ref-for-ecmascript-throw-4">(2)</a>
<li><a href="#ref-for-ecmascript-throw-5">3.2.6. short</a> <a href="#ref-for-ecmascript-throw-6">(2)</a>
<li><a href="#ref-for-ecmascript-throw-7">3.2.7. unsigned short</a> <a href="#ref-for-ecmascript-throw-8">(2)</a>
<li><a href="#ref-for-ecmascript-throw-9">3.2.8. long</a> <a href="#ref-for-ecmascript-throw-10">(2)</a>
<li><a href="#ref-for-ecmascript-throw-11">3.2.9. unsigned long</a> <a href="#ref-for-ecmascript-throw-12">(2)</a>
<li><a href="#ref-for-ecmascript-throw-13">3.2.10. long long</a> <a href="#ref-for-ecmascript-throw-14">(2)</a>
<li><a href="#ref-for-ecmascript-throw-15">3.2.11. unsigned long long</a> <a href="#ref-for-ecmascript-throw-16">(2)</a>
<li><a href="#ref-for-ecmascript-throw-17">3.2.12. float</a> <a href="#ref-for-ecmascript-throw-18">(2)</a>
<li><a href="#ref-for-ecmascript-throw-19">3.2.14. double</a>
<li><a href="#ref-for-ecmascript-throw-20">3.2.17. ByteString</a>
<li><a href="#ref-for-ecmascript-throw-21">3.2.19. object</a>
<li><a href="#ref-for-ecmascript-throw-22">3.2.20. Interface types</a> <a href="#ref-for-ecmascript-throw-23">(2)</a>
<li><a href="#ref-for-ecmascript-throw-24">3.2.21. Dictionary types</a> <a href="#ref-for-ecmascript-throw-25">(2)</a>
<li><a href="#ref-for-ecmascript-throw-26">3.2.22. Enumeration types</a>
<li><a href="#ref-for-ecmascript-throw-27">3.2.23. Callback function types</a>
<li><a href="#ref-for-ecmascript-throw-28">3.2.25. Sequences — sequence<T></a> <a href="#ref-for-ecmascript-throw-29">(2)</a> <a href="#ref-for-ecmascript-throw-30">(3)</a>
<li><a href="#ref-for-ecmascript-throw-31">3.2.26. Open dictionaries — OpenDictionary<[K,] V></a>
<li><a href="#ref-for-ecmascript-throw-32">3.2.27. Promise types — Promise<T></a>
<li><a href="#ref-for-ecmascript-throw-33">3.2.28. Union types</a>
<li><a href="#ref-for-ecmascript-throw-34">3.2.30. Error</a>
<li><a href="#ref-for-ecmascript-throw-35">3.2.31. DOMException</a>
<li><a href="#ref-for-ecmascript-throw-36">3.2.32. Buffer source types</a> <a href="#ref-for-ecmascript-throw-37">(2)</a> <a href="#ref-for-ecmascript-throw-38">(3)</a> <a href="#ref-for-ecmascript-throw-39">(4)</a> <a href="#ref-for-ecmascript-throw-40">(5)</a>
<li><a href="#ref-for-ecmascript-throw-41">3.5. Overload resolution algorithm</a> <a href="#ref-for-ecmascript-throw-42">(2)</a>
<li><a href="#ref-for-ecmascript-throw-43">3.6.1.1. Interface object [[Call]] method</a>
<li><a href="#ref-for-ecmascript-throw-44">3.6.1.2. Interface object [[HasInstance]] method</a>
<li><a href="#ref-for-ecmascript-throw-45">3.6.6. Attributes</a> <a href="#ref-for-ecmascript-throw-46">(2)</a> <a href="#ref-for-ecmascript-throw-47">(3)</a> <a href="#ref-for-ecmascript-throw-48">(4)</a>
<li><a href="#ref-for-ecmascript-throw-49">3.6.7. Operations</a>
<li><a href="#ref-for-ecmascript-throw-50">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-ecmascript-throw-51">3.6.7.2. Serializers</a>
<li><a href="#ref-for-ecmascript-throw-52">3.6.8.1. @@iterator</a> <a href="#ref-for-ecmascript-throw-53">(2)</a>
<li><a href="#ref-for-ecmascript-throw-54">3.6.8.2. forEach</a> <a href="#ref-for-ecmascript-throw-55">(2)</a> <a href="#ref-for-ecmascript-throw-56">(3)</a>
<li><a href="#ref-for-ecmascript-throw-57">3.6.9.2. keys</a>
<li><a href="#ref-for-ecmascript-throw-58">3.6.9.3. values</a>
<li><a href="#ref-for-ecmascript-throw-59">3.6.9.5. Iterator prototype object</a>
<li><a href="#ref-for-ecmascript-throw-60">3.6.10. Maplike declarations</a> <a href="#ref-for-ecmascript-throw-61">(2)</a>
<li><a href="#ref-for-ecmascript-throw-62">3.6.10.1. size</a>
<li><a href="#ref-for-ecmascript-throw-63">3.6.10.4. get and has</a>
<li><a href="#ref-for-ecmascript-throw-64">3.6.10.6. delete</a>
<li><a href="#ref-for-ecmascript-throw-65">3.6.10.7. set</a>
<li><a href="#ref-for-ecmascript-throw-66">3.6.11. Setlike declarations</a> <a href="#ref-for-ecmascript-throw-67">(2)</a>
<li><a href="#ref-for-ecmascript-throw-68">3.6.11.1. size</a>
<li><a href="#ref-for-ecmascript-throw-69">3.6.11.4. has</a>
<li><a href="#ref-for-ecmascript-throw-70">3.6.11.5. add and delete</a>
<li><a href="#ref-for-ecmascript-throw-71">3.8.1. Indexed and named properties</a> <a href="#ref-for-ecmascript-throw-72">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-initial-object">
<b><a href="#dfn-initial-object">#dfn-initial-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-initial-object-1">3.1. ECMAScript environment</a> <a href="#ref-for-dfn-initial-object-2">(2)</a>
<li><a href="#ref-for-dfn-initial-object-3">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-initial-object-4">3.8. Platform objects implementing interfaces</a>
<li><a href="#ref-for-dfn-initial-object-5">3.13. Exception objects</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-expose">
<b><a href="#dfn-expose">#dfn-expose</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-expose-1">3.1. ECMAScript environment</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-associated-realm">
<b><a href="#dfn-associated-realm">#dfn-associated-realm</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-associated-realm-1">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-associated-realm-2">(2)</a> <a href="#ref-for-dfn-associated-realm-3">(3)</a>
<li><a href="#ref-for-dfn-associated-realm-4">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-convert-ecmascript-to-idl-value">
<b><a href="#dfn-convert-ecmascript-to-idl-value">#dfn-convert-ecmascript-to-idl-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-1">3.2.1. any</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-2">3.2.3. boolean</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-3">3.2.4. byte</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-4">3.2.5. octet</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-5">3.2.6. short</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-6">3.2.7. unsigned short</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-7">3.2.8. long</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-8">3.2.9. unsigned long</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-9">3.2.10. long long</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-10">3.2.11. unsigned long long</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-11">3.2.12. float</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-12">3.2.13. unrestricted float</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-13">3.2.14. double</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-14">3.2.15. unrestricted double</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-15">3.2.16. DOMString</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-16">3.2.17. ByteString</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-17">3.2.18. USVString</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-18">(2)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-19">3.2.19. object</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-20">3.2.20. Interface types</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-21">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-22">(2)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-23">3.2.22. Enumeration types</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-24">3.2.23. Callback function types</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-25">3.2.24. Nullable types — T?</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-26">(2)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-27">3.2.25. Sequences — sequence<T></a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-28">3.2.25.1. Creating a sequence from an iterable</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-29">3.2.26. Open dictionaries — OpenDictionary<[K,] V></a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-30">(2)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-31">(3)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-32">3.2.27. Promise types — Promise<T></a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-33">(2)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-34">(3)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-35">3.2.28. Union types</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-36">(2)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-37">(3)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-38">(4)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-39">(5)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-40">(6)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-41">(7)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-42">(8)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-43">(9)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-44">(10)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-45">(11)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-46">(12)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-47">(13)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-48">(14)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-49">(15)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-50">(16)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-51">3.2.29. RegExp</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-52">3.2.30. Error</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-53">3.2.31. DOMException</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-54">3.2.32. Buffer source types</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-55">(2)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-56">(3)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-57">3.2.33. Frozen arrays — FrozenArray<T></a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-58">(2)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-59">3.5. Overload resolution algorithm</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-60">(2)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-61">3.6.6. Attributes</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-62">3.6.10.4. get and has</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-63">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-64">3.6.10.7. set</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-65">(2)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-66">3.6.11.4. has</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-67">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-68">3.8.4. Invoking a platform object indexed property setter</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-69">3.8.5. Invoking a platform object named property setter</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-70">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-71">(2)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-72">(3)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-73">(4)</a>
<li><a href="#ref-for-dfn-convert-ecmascript-to-idl-value-74">3.10. Invoking callback functions</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-75">(2)</a> <a href="#ref-for-dfn-convert-ecmascript-to-idl-value-76">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-convert-idl-to-ecmascript-value">
<b><a href="#dfn-convert-idl-to-ecmascript-value">#dfn-convert-idl-to-ecmascript-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-1">3.2.1. any</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-2">3.2.3. boolean</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-3">3.2.4. byte</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-4">3.2.5. octet</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-5">3.2.6. short</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-6">3.2.7. unsigned short</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-7">3.2.8. long</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-8">3.2.9. unsigned long</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-9">3.2.10. long long</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-10">3.2.11. unsigned long long</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-11">3.2.12. float</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-12">3.2.13. unrestricted float</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-13">3.2.14. double</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-14">3.2.15. unrestricted double</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-15">3.2.16. DOMString</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-16">3.2.17. ByteString</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-17">3.2.18. USVString</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-18">3.2.19. object</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-19">3.2.20. Interface types</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-20">3.2.21. Dictionary types</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-21">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-22">3.2.22. Enumeration types</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-23">3.2.23. Callback function types</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-24">3.2.24. Nullable types — T?</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-25">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-26">3.2.25. Sequences — sequence<T></a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-27">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-28">3.2.26. Open dictionaries — OpenDictionary<[K,] V></a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-29">(2)</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-30">(3)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-31">3.2.27. Promise types — Promise<T></a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-32">3.2.28. Union types</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-33">3.2.29. RegExp</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-34">3.2.30. Error</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-35">3.2.31. DOMException</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-36">3.2.32. Buffer source types</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-37">3.2.33. Frozen arrays — FrozenArray<T></a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-38">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-39">3.6.1.1. Interface object [[Call]] method</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-40">3.6.2. Named constructors</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-41">3.6.4.1. Named properties object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-42">3.6.5. Constants</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-43">3.6.6. Attributes</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-44">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-45">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-46">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-47">3.6.9.5. Iterator prototype object</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-48">(2)</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-49">(3)</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-50">(4)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-51">3.6.10.4. get and has</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-52">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-53">3.6.10.7. set</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-54">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-55">3.6.11.4. has</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-56">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-57">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-58">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-59">3.8.9. Platform object [[Call]] method</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-60">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-61">(2)</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-62">3.10. Invoking callback functions</a>
<li><a href="#ref-for-dfn-convert-idl-to-ecmascript-value-63">3.14. Creating and throwing exceptions</a> <a href="#ref-for-dfn-convert-idl-to-ecmascript-value-64">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="create-sequence-from-iterable">
<b><a href="#create-sequence-from-iterable">#create-sequence-from-iterable</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-create-sequence-from-iterable-1">3.2.25. Sequences — sequence<T></a>
<li><a href="#ref-for-create-sequence-from-iterable-2">3.2.28. Union types</a>
<li><a href="#ref-for-create-sequence-from-iterable-3">3.2.33.1. Creating a frozen array from an iterable</a>
<li><a href="#ref-for-create-sequence-from-iterable-4">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-create-frozen-array">
<b><a href="#dfn-create-frozen-array">#dfn-create-frozen-array</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-create-frozen-array-1">3.2.33. Frozen arrays — FrozenArray<T></a>
<li><a href="#ref-for-dfn-create-frozen-array-2">3.2.33.1. Creating a frozen array from an iterable</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="create-frozen-array-from-iterable">
<b><a href="#create-frozen-array-from-iterable">#create-frozen-array-from-iterable</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-create-frozen-array-from-iterable-1">3.2.28. Union types</a>
<li><a href="#ref-for-create-frozen-array-from-iterable-2">3.5. Overload resolution algorithm</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Clamp">
<b><a href="#Clamp">#Clamp</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Clamp-1">2.2.2. Attributes</a>
<li><a href="#ref-for-Clamp-2">2.2.3. Operations</a>
<li><a href="#ref-for-Clamp-3">2.4. Dictionaries</a>
<li><a href="#ref-for-Clamp-4">3.2.4. byte</a> <a href="#ref-for-Clamp-5">(2)</a> <a href="#ref-for-Clamp-6">(3)</a>
<li><a href="#ref-for-Clamp-7">3.2.5. octet</a> <a href="#ref-for-Clamp-8">(2)</a> <a href="#ref-for-Clamp-9">(3)</a>
<li><a href="#ref-for-Clamp-10">3.2.6. short</a> <a href="#ref-for-Clamp-11">(2)</a> <a href="#ref-for-Clamp-12">(3)</a>
<li><a href="#ref-for-Clamp-13">3.2.7. unsigned short</a> <a href="#ref-for-Clamp-14">(2)</a> <a href="#ref-for-Clamp-15">(3)</a>
<li><a href="#ref-for-Clamp-16">3.2.8. long</a> <a href="#ref-for-Clamp-17">(2)</a> <a href="#ref-for-Clamp-18">(3)</a>
<li><a href="#ref-for-Clamp-19">3.2.9. unsigned long</a> <a href="#ref-for-Clamp-20">(2)</a> <a href="#ref-for-Clamp-21">(3)</a>
<li><a href="#ref-for-Clamp-22">3.2.10. long long</a> <a href="#ref-for-Clamp-23">(2)</a> <a href="#ref-for-Clamp-24">(3)</a>
<li><a href="#ref-for-Clamp-25">3.2.11. unsigned long long</a> <a href="#ref-for-Clamp-26">(2)</a> <a href="#ref-for-Clamp-27">(3)</a>
<li><a href="#ref-for-Clamp-28">3.3.1. [Clamp]</a> <a href="#ref-for-Clamp-29">(2)</a> <a href="#ref-for-Clamp-30">(3)</a> <a href="#ref-for-Clamp-31">(4)</a> <a href="#ref-for-Clamp-32">(5)</a>
<li><a href="#ref-for-Clamp-33">3.3.3. [EnforceRange]</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Constructor">
<b><a href="#Constructor">#Constructor</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Constructor-1">2. Interface definition language</a>
<li><a href="#ref-for-Constructor-2">2.2. Interfaces</a> <a href="#ref-for-Constructor-3">(2)</a>
<li><a href="#ref-for-Constructor-4">2.2.3. Operations</a>
<li><a href="#ref-for-Constructor-5">2.2.6. Overloading</a> <a href="#ref-for-Constructor-6">(2)</a> <a href="#ref-for-Constructor-7">(3)</a> <a href="#ref-for-Constructor-8">(4)</a> <a href="#ref-for-Constructor-9">(5)</a>
<li><a href="#ref-for-Constructor-10">2.4. Dictionaries</a>
<li><a href="#ref-for-Constructor-11">3.3.2. [Constructor]</a> <a href="#ref-for-Constructor-12">(2)</a> <a href="#ref-for-Constructor-13">(3)</a> <a href="#ref-for-Constructor-14">(4)</a> <a href="#ref-for-Constructor-15">(5)</a> <a href="#ref-for-Constructor-16">(6)</a> <a href="#ref-for-Constructor-17">(7)</a> <a href="#ref-for-Constructor-18">(8)</a>
<li><a href="#ref-for-Constructor-19">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-Constructor-20">3.6.1.1. Interface object [[Call]] method</a> <a href="#ref-for-Constructor-21">(2)</a> <a href="#ref-for-Constructor-22">(3)</a>
<li><a href="#ref-for-Constructor-23">3.14. Creating and throwing exceptions</a>
<li><a href="#ref-for-Constructor-24">IDL grammar</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="EnforceRange">
<b><a href="#EnforceRange">#EnforceRange</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-EnforceRange-1">2.2.2. Attributes</a>
<li><a href="#ref-for-EnforceRange-2">2.2.3. Operations</a>
<li><a href="#ref-for-EnforceRange-3">2.4. Dictionaries</a>
<li><a href="#ref-for-EnforceRange-4">3.2.4. byte</a> <a href="#ref-for-EnforceRange-5">(2)</a> <a href="#ref-for-EnforceRange-6">(3)</a>
<li><a href="#ref-for-EnforceRange-7">3.2.5. octet</a> <a href="#ref-for-EnforceRange-8">(2)</a> <a href="#ref-for-EnforceRange-9">(3)</a>
<li><a href="#ref-for-EnforceRange-10">3.2.6. short</a> <a href="#ref-for-EnforceRange-11">(2)</a> <a href="#ref-for-EnforceRange-12">(3)</a>
<li><a href="#ref-for-EnforceRange-13">3.2.7. unsigned short</a> <a href="#ref-for-EnforceRange-14">(2)</a> <a href="#ref-for-EnforceRange-15">(3)</a>
<li><a href="#ref-for-EnforceRange-16">3.2.8. long</a> <a href="#ref-for-EnforceRange-17">(2)</a> <a href="#ref-for-EnforceRange-18">(3)</a>
<li><a href="#ref-for-EnforceRange-19">3.2.9. unsigned long</a> <a href="#ref-for-EnforceRange-20">(2)</a> <a href="#ref-for-EnforceRange-21">(3)</a>
<li><a href="#ref-for-EnforceRange-22">3.2.10. long long</a> <a href="#ref-for-EnforceRange-23">(2)</a> <a href="#ref-for-EnforceRange-24">(3)</a>
<li><a href="#ref-for-EnforceRange-25">3.2.11. unsigned long long</a> <a href="#ref-for-EnforceRange-26">(2)</a> <a href="#ref-for-EnforceRange-27">(3)</a>
<li><a href="#ref-for-EnforceRange-28">3.3.1. [Clamp]</a>
<li><a href="#ref-for-EnforceRange-29">3.3.3. [EnforceRange]</a> <a href="#ref-for-EnforceRange-30">(2)</a> <a href="#ref-for-EnforceRange-31">(3)</a> <a href="#ref-for-EnforceRange-32">(4)</a> <a href="#ref-for-EnforceRange-33">(5)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Exposed">
<b><a href="#Exposed">#Exposed</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Exposed-1">2.2. Interfaces</a> <a href="#ref-for-Exposed-2">(2)</a>
<li><a href="#ref-for-Exposed-3">2.2.1. Constants</a>
<li><a href="#ref-for-Exposed-4">2.2.2. Attributes</a>
<li><a href="#ref-for-Exposed-5">2.2.3. Operations</a>
<li><a href="#ref-for-Exposed-6">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-Exposed-7">2.3. Namespaces</a>
<li><a href="#ref-for-Exposed-8">2.4. Dictionaries</a>
<li><a href="#ref-for-Exposed-9">3.3.4. [Exposed]</a> <a href="#ref-for-Exposed-10">(2)</a> <a href="#ref-for-Exposed-11">(3)</a> <a href="#ref-for-Exposed-12">(4)</a> <a href="#ref-for-Exposed-13">(5)</a> <a href="#ref-for-Exposed-14">(6)</a> <a href="#ref-for-Exposed-15">(7)</a> <a href="#ref-for-Exposed-16">(8)</a> <a href="#ref-for-Exposed-17">(9)</a> <a href="#ref-for-Exposed-18">(10)</a> <a href="#ref-for-Exposed-19">(11)</a> <a href="#ref-for-Exposed-20">(12)</a>
<li><a href="#ref-for-Exposed-21">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-Exposed-22">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-exposure-set">
<b><a href="#dfn-exposure-set">#dfn-exposure-set</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-exposure-set-1">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-exposure-set-2">(2)</a> <a href="#ref-for-dfn-exposure-set-3">(3)</a> <a href="#ref-for-dfn-exposure-set-4">(4)</a> <a href="#ref-for-dfn-exposure-set-5">(5)</a> <a href="#ref-for-dfn-exposure-set-6">(6)</a> <a href="#ref-for-dfn-exposure-set-7">(7)</a> <a href="#ref-for-dfn-exposure-set-8">(8)</a> <a href="#ref-for-dfn-exposure-set-9">(9)</a> <a href="#ref-for-dfn-exposure-set-10">(10)</a> <a href="#ref-for-dfn-exposure-set-11">(11)</a> <a href="#ref-for-dfn-exposure-set-12">(12)</a> <a href="#ref-for-dfn-exposure-set-13">(13)</a> <a href="#ref-for-dfn-exposure-set-14">(14)</a> <a href="#ref-for-dfn-exposure-set-15">(15)</a> <a href="#ref-for-dfn-exposure-set-16">(16)</a> <a href="#ref-for-dfn-exposure-set-17">(17)</a> <a href="#ref-for-dfn-exposure-set-18">(18)</a> <a href="#ref-for-dfn-exposure-set-19">(19)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-exposed">
<b><a href="#dfn-exposed">#dfn-exposed</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-exposed-1">3.3.17. [SecureContext]</a>
<li><a href="#ref-for-dfn-exposed-2">3.6. Interfaces</a> <a href="#ref-for-dfn-exposed-3">(2)</a>
<li><a href="#ref-for-dfn-exposed-4">3.6.5. Constants</a>
<li><a href="#ref-for-dfn-exposed-5">3.6.6. Attributes</a>
<li><a href="#ref-for-dfn-exposed-6">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-exposed-7">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-exposed-8">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-exposed-9">3.11. Namespaces</a>
<li><a href="#ref-for-dfn-exposed-10">3.11.1. Namespace object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Global">
<b><a href="#Global">#Global</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Global-1">2.2. Interfaces</a> <a href="#ref-for-Global-2">(2)</a> <a href="#ref-for-Global-3">(3)</a> <a href="#ref-for-Global-4">(4)</a>
<li><a href="#ref-for-Global-5">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-Global-6">(2)</a> <a href="#ref-for-Global-7">(3)</a> <a href="#ref-for-Global-8">(4)</a> <a href="#ref-for-Global-9">(5)</a> <a href="#ref-for-Global-10">(6)</a> <a href="#ref-for-Global-11">(7)</a> <a href="#ref-for-Global-12">(8)</a> <a href="#ref-for-Global-13">(9)</a> <a href="#ref-for-Global-14">(10)</a> <a href="#ref-for-Global-15">(11)</a> <a href="#ref-for-Global-16">(12)</a> <a href="#ref-for-Global-17">(13)</a> <a href="#ref-for-Global-18">(14)</a> <a href="#ref-for-Global-19">(15)</a> <a href="#ref-for-Global-20">(16)</a> <a href="#ref-for-Global-21">(17)</a> <a href="#ref-for-Global-22">(18)</a> <a href="#ref-for-Global-23">(19)</a> <a href="#ref-for-Global-24">(20)</a> <a href="#ref-for-Global-25">(21)</a> <a href="#ref-for-Global-26">(22)</a> <a href="#ref-for-Global-27">(23)</a> <a href="#ref-for-Global-28">(24)</a>
<li><a href="#ref-for-Global-29">3.3.13. [OverrideBuiltins]</a> <a href="#ref-for-Global-30">(2)</a>
<li><a href="#ref-for-Global-31">3.6.3. Interface prototype object</a> <a href="#ref-for-Global-32">(2)</a> <a href="#ref-for-Global-33">(3)</a> <a href="#ref-for-Global-34">(4)</a>
<li><a href="#ref-for-Global-35">3.6.4. Named properties object</a> <a href="#ref-for-Global-36">(2)</a>
<li><a href="#ref-for-Global-37">3.6.5. Constants</a> <a href="#ref-for-Global-38">(2)</a> <a href="#ref-for-Global-39">(3)</a> <a href="#ref-for-Global-40">(4)</a> <a href="#ref-for-Global-41">(5)</a> <a href="#ref-for-Global-42">(6)</a>
<li><a href="#ref-for-Global-43">3.6.6. Attributes</a> <a href="#ref-for-Global-44">(2)</a> <a href="#ref-for-Global-45">(3)</a> <a href="#ref-for-Global-46">(4)</a> <a href="#ref-for-Global-47">(5)</a> <a href="#ref-for-Global-48">(6)</a>
<li><a href="#ref-for-Global-49">3.6.7. Operations</a> <a href="#ref-for-Global-50">(2)</a> <a href="#ref-for-Global-51">(3)</a> <a href="#ref-for-Global-52">(4)</a> <a href="#ref-for-Global-53">(5)</a> <a href="#ref-for-Global-54">(6)</a>
<li><a href="#ref-for-Global-55">3.6.7.1. Stringifiers</a> <a href="#ref-for-Global-56">(2)</a>
<li><a href="#ref-for-Global-57">3.6.7.2. Serializers</a> <a href="#ref-for-Global-58">(2)</a> <a href="#ref-for-Global-59">(3)</a> <a href="#ref-for-Global-60">(4)</a> <a href="#ref-for-Global-61">(5)</a> <a href="#ref-for-Global-62">(6)</a>
<li><a href="#ref-for-Global-63">3.6.8.1. @@iterator</a> <a href="#ref-for-Global-64">(2)</a> <a href="#ref-for-Global-65">(3)</a> <a href="#ref-for-Global-66">(4)</a> <a href="#ref-for-Global-67">(5)</a> <a href="#ref-for-Global-68">(6)</a>
<li><a href="#ref-for-Global-69">3.6.8.2. forEach</a> <a href="#ref-for-Global-70">(2)</a> <a href="#ref-for-Global-71">(3)</a> <a href="#ref-for-Global-72">(4)</a> <a href="#ref-for-Global-73">(5)</a> <a href="#ref-for-Global-74">(6)</a>
<li><a href="#ref-for-Global-75">3.6.9.1. entries</a> <a href="#ref-for-Global-76">(2)</a> <a href="#ref-for-Global-77">(3)</a> <a href="#ref-for-Global-78">(4)</a> <a href="#ref-for-Global-79">(5)</a> <a href="#ref-for-Global-80">(6)</a>
<li><a href="#ref-for-Global-81">3.6.9.2. keys</a> <a href="#ref-for-Global-82">(2)</a> <a href="#ref-for-Global-83">(3)</a> <a href="#ref-for-Global-84">(4)</a> <a href="#ref-for-Global-85">(5)</a> <a href="#ref-for-Global-86">(6)</a>
<li><a href="#ref-for-Global-87">3.6.9.3. values</a> <a href="#ref-for-Global-88">(2)</a> <a href="#ref-for-Global-89">(3)</a> <a href="#ref-for-Global-90">(4)</a> <a href="#ref-for-Global-91">(5)</a> <a href="#ref-for-Global-92">(6)</a>
<li><a href="#ref-for-Global-93">3.8.1. Indexed and named properties</a> <a href="#ref-for-Global-94">(2)</a> <a href="#ref-for-Global-95">(3)</a> <a href="#ref-for-Global-96">(4)</a>
<li><a href="#ref-for-Global-97">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a> <a href="#ref-for-Global-98">(2)</a>
<li><a href="#ref-for-Global-99">3.8.7. Platform object [[DefineOwnProperty]] method</a> <a href="#ref-for-Global-100">(2)</a> <a href="#ref-for-Global-101">(3)</a> <a href="#ref-for-Global-102">(4)</a>
<li><a href="#ref-for-Global-103">3.8.8. Platform object [[Delete]] method</a> <a href="#ref-for-Global-104">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-global-name">
<b><a href="#dfn-global-name">#dfn-global-name</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-global-name-1">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-global-name-2">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-primary-global-interface">
<b><a href="#dfn-primary-global-interface">#dfn-primary-global-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-primary-global-interface-1">3.3.4. [Exposed]</a> <a href="#ref-for-dfn-primary-global-interface-2">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="LegacyArrayClass">
<b><a href="#LegacyArrayClass">#LegacyArrayClass</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-LegacyArrayClass-1">2.2. Interfaces</a> <a href="#ref-for-LegacyArrayClass-2">(2)</a>
<li><a href="#ref-for-LegacyArrayClass-3">3.3.6. [LegacyArrayClass]</a> <a href="#ref-for-LegacyArrayClass-4">(2)</a> <a href="#ref-for-LegacyArrayClass-5">(3)</a> <a href="#ref-for-LegacyArrayClass-6">(4)</a> <a href="#ref-for-LegacyArrayClass-7">(5)</a>
<li><a href="#ref-for-LegacyArrayClass-8">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-LegacyArrayClass-9">3.6.4. Named properties object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="LegacyUnenumerableNamedProperties">
<b><a href="#LegacyUnenumerableNamedProperties">#LegacyUnenumerableNamedProperties</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-LegacyUnenumerableNamedProperties-1">3.3.7. [LegacyUnenumerableNamedProperties]</a> <a href="#ref-for-LegacyUnenumerableNamedProperties-2">(2)</a> <a href="#ref-for-LegacyUnenumerableNamedProperties-3">(3)</a> <a href="#ref-for-LegacyUnenumerableNamedProperties-4">(4)</a>
<li><a href="#ref-for-LegacyUnenumerableNamedProperties-5">3.6.4.1. Named properties object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-LegacyUnenumerableNamedProperties-6">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-LegacyUnenumerableNamedProperties-7">3.8.10. Property enumeration</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="LenientSetter">
<b><a href="#LenientSetter">#LenientSetter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-LenientSetter-1">2.2.2. Attributes</a>
<li><a href="#ref-for-LenientSetter-2">3.3.8. [LenientSetter]</a> <a href="#ref-for-LenientSetter-3">(2)</a> <a href="#ref-for-LenientSetter-4">(3)</a> <a href="#ref-for-LenientSetter-5">(4)</a> <a href="#ref-for-LenientSetter-6">(5)</a> <a href="#ref-for-LenientSetter-7">(6)</a>
<li><a href="#ref-for-LenientSetter-8">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-LenientSetter-9">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-LenientSetter-10">3.6.6. Attributes</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="LenientThis">
<b><a href="#LenientThis">#LenientThis</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-LenientThis-1">2.2.2. Attributes</a>
<li><a href="#ref-for-LenientThis-2">3.3.8. [LenientSetter]</a>
<li><a href="#ref-for-LenientThis-3">3.3.9. [LenientThis]</a> <a href="#ref-for-LenientThis-4">(2)</a> <a href="#ref-for-LenientThis-5">(3)</a> <a href="#ref-for-LenientThis-6">(4)</a> <a href="#ref-for-LenientThis-7">(5)</a>
<li><a href="#ref-for-LenientThis-8">3.6.6. Attributes</a> <a href="#ref-for-LenientThis-9">(2)</a> <a href="#ref-for-LenientThis-10">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="NamedConstructor">
<b><a href="#NamedConstructor">#NamedConstructor</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-NamedConstructor-1">2.2. Interfaces</a> <a href="#ref-for-NamedConstructor-2">(2)</a>
<li><a href="#ref-for-NamedConstructor-3">2.2.3. Operations</a>
<li><a href="#ref-for-NamedConstructor-4">2.2.6. Overloading</a> <a href="#ref-for-NamedConstructor-5">(2)</a> <a href="#ref-for-NamedConstructor-6">(3)</a> <a href="#ref-for-NamedConstructor-7">(4)</a>
<li><a href="#ref-for-NamedConstructor-8">3.3.10. [NamedConstructor]</a> <a href="#ref-for-NamedConstructor-9">(2)</a> <a href="#ref-for-NamedConstructor-10">(3)</a> <a href="#ref-for-NamedConstructor-11">(4)</a> <a href="#ref-for-NamedConstructor-12">(5)</a> <a href="#ref-for-NamedConstructor-13">(6)</a> <a href="#ref-for-NamedConstructor-14">(7)</a>
<li><a href="#ref-for-NamedConstructor-15">3.3.12. [NoInterfaceObject]</a>
<li><a href="#ref-for-NamedConstructor-16">3.6. Interfaces</a>
<li><a href="#ref-for-NamedConstructor-17">3.6.2. Named constructors</a> <a href="#ref-for-NamedConstructor-18">(2)</a> <a href="#ref-for-NamedConstructor-19">(3)</a> <a href="#ref-for-NamedConstructor-20">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="NewObject">
<b><a href="#NewObject">#NewObject</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-NewObject-1">2.2.3. Operations</a>
<li><a href="#ref-for-NewObject-2">3.3.11. [NewObject]</a> <a href="#ref-for-NewObject-3">(2)</a> <a href="#ref-for-NewObject-4">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="NoInterfaceObject">
<b><a href="#NoInterfaceObject">#NoInterfaceObject</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-NoInterfaceObject-1">2.2. Interfaces</a> <a href="#ref-for-NoInterfaceObject-2">(2)</a>
<li><a href="#ref-for-NoInterfaceObject-3">3.3.2. [Constructor]</a>
<li><a href="#ref-for-NoInterfaceObject-4">3.3.12. [NoInterfaceObject]</a> <a href="#ref-for-NoInterfaceObject-5">(2)</a> <a href="#ref-for-NoInterfaceObject-6">(3)</a> <a href="#ref-for-NoInterfaceObject-7">(4)</a> <a href="#ref-for-NoInterfaceObject-8">(5)</a> <a href="#ref-for-NoInterfaceObject-9">(6)</a> <a href="#ref-for-NoInterfaceObject-10">(7)</a> <a href="#ref-for-NoInterfaceObject-11">(8)</a> <a href="#ref-for-NoInterfaceObject-12">(9)</a>
<li><a href="#ref-for-NoInterfaceObject-13">3.6. Interfaces</a>
<li><a href="#ref-for-NoInterfaceObject-14">3.6.3. Interface prototype object</a> <a href="#ref-for-NoInterfaceObject-15">(2)</a> <a href="#ref-for-NoInterfaceObject-16">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="OverrideBuiltins">
<b><a href="#OverrideBuiltins">#OverrideBuiltins</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-OverrideBuiltins-1">2.2. Interfaces</a> <a href="#ref-for-OverrideBuiltins-2">(2)</a>
<li><a href="#ref-for-OverrideBuiltins-3">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-OverrideBuiltins-4">(2)</a>
<li><a href="#ref-for-OverrideBuiltins-5">3.3.13. [OverrideBuiltins]</a> <a href="#ref-for-OverrideBuiltins-6">(2)</a> <a href="#ref-for-OverrideBuiltins-7">(3)</a>
<li><a href="#ref-for-OverrideBuiltins-8">3.8.1. Indexed and named properties</a> <a href="#ref-for-OverrideBuiltins-9">(2)</a> <a href="#ref-for-OverrideBuiltins-10">(3)</a> <a href="#ref-for-OverrideBuiltins-11">(4)</a>
<li><a href="#ref-for-OverrideBuiltins-12">3.8.7. Platform object [[DefineOwnProperty]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="PutForwards">
<b><a href="#PutForwards">#PutForwards</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-PutForwards-1">2.2.2. Attributes</a>
<li><a href="#ref-for-PutForwards-2">3.3.8. [LenientSetter]</a>
<li><a href="#ref-for-PutForwards-3">3.3.14. [PutForwards]</a> <a href="#ref-for-PutForwards-4">(2)</a> <a href="#ref-for-PutForwards-5">(3)</a> <a href="#ref-for-PutForwards-6">(4)</a> <a href="#ref-for-PutForwards-7">(5)</a> <a href="#ref-for-PutForwards-8">(6)</a> <a href="#ref-for-PutForwards-9">(7)</a> <a href="#ref-for-PutForwards-10">(8)</a> <a href="#ref-for-PutForwards-11">(9)</a> <a href="#ref-for-PutForwards-12">(10)</a> <a href="#ref-for-PutForwards-13">(11)</a>
<li><a href="#ref-for-PutForwards-14">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-PutForwards-15">3.6.6. Attributes</a> <a href="#ref-for-PutForwards-16">(2)</a> <a href="#ref-for-PutForwards-17">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Replaceable">
<b><a href="#Replaceable">#Replaceable</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Replaceable-1">2.2.2. Attributes</a>
<li><a href="#ref-for-Replaceable-2">3.3.8. [LenientSetter]</a>
<li><a href="#ref-for-Replaceable-3">3.3.14. [PutForwards]</a>
<li><a href="#ref-for-Replaceable-4">3.3.15. [Replaceable]</a> <a href="#ref-for-Replaceable-5">(2)</a> <a href="#ref-for-Replaceable-6">(3)</a> <a href="#ref-for-Replaceable-7">(4)</a> <a href="#ref-for-Replaceable-8">(5)</a> <a href="#ref-for-Replaceable-9">(6)</a> <a href="#ref-for-Replaceable-10">(7)</a>
<li><a href="#ref-for-Replaceable-11">3.6.6. Attributes</a> <a href="#ref-for-Replaceable-12">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="SameObject">
<b><a href="#SameObject">#SameObject</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-SameObject-1">2.2.2. Attributes</a>
<li><a href="#ref-for-SameObject-2">3.3.16. [SameObject]</a> <a href="#ref-for-SameObject-3">(2)</a> <a href="#ref-for-SameObject-4">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="SecureContext">
<b><a href="#SecureContext">#SecureContext</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-SecureContext-1">2.2. Interfaces</a> <a href="#ref-for-SecureContext-2">(2)</a>
<li><a href="#ref-for-SecureContext-3">2.2.1. Constants</a>
<li><a href="#ref-for-SecureContext-4">2.2.2. Attributes</a>
<li><a href="#ref-for-SecureContext-5">2.2.3. Operations</a>
<li><a href="#ref-for-SecureContext-6">2.2.7. Iterable declarations</a>
<li><a href="#ref-for-SecureContext-7">2.3. Namespaces</a>
<li><a href="#ref-for-SecureContext-8">2.4. Dictionaries</a>
<li><a href="#ref-for-SecureContext-9">3.3.17. [SecureContext]</a> <a href="#ref-for-SecureContext-10">(2)</a> <a href="#ref-for-SecureContext-11">(3)</a> <a href="#ref-for-SecureContext-12">(4)</a> <a href="#ref-for-SecureContext-13">(5)</a> <a href="#ref-for-SecureContext-14">(6)</a> <a href="#ref-for-SecureContext-15">(7)</a> <a href="#ref-for-SecureContext-16">(8)</a> <a href="#ref-for-SecureContext-17">(9)</a> <a href="#ref-for-SecureContext-18">(10)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-available-only-in-secure-contexts">
<b><a href="#dfn-available-only-in-secure-contexts">#dfn-available-only-in-secure-contexts</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-available-only-in-secure-contexts-1">3.3.4. [Exposed]</a>
<li><a href="#ref-for-dfn-available-only-in-secure-contexts-2">3.3.17. [SecureContext]</a> <a href="#ref-for-dfn-available-only-in-secure-contexts-3">(2)</a> <a href="#ref-for-dfn-available-only-in-secure-contexts-4">(3)</a> <a href="#ref-for-dfn-available-only-in-secure-contexts-5">(4)</a> <a href="#ref-for-dfn-available-only-in-secure-contexts-6">(5)</a> <a href="#ref-for-dfn-available-only-in-secure-contexts-7">(6)</a> <a href="#ref-for-dfn-available-only-in-secure-contexts-8">(7)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="TreatNonObjectAsNull">
<b><a href="#TreatNonObjectAsNull">#TreatNonObjectAsNull</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-TreatNonObjectAsNull-1">2.7. Callback functions</a>
<li><a href="#ref-for-TreatNonObjectAsNull-2">3.2.23. Callback function types</a> <a href="#ref-for-TreatNonObjectAsNull-3">(2)</a>
<li><a href="#ref-for-TreatNonObjectAsNull-4">3.2.24. Nullable types — T?</a>
<li><a href="#ref-for-TreatNonObjectAsNull-5">3.3.18. [TreatNonObjectAsNull]</a> <a href="#ref-for-TreatNonObjectAsNull-6">(2)</a> <a href="#ref-for-TreatNonObjectAsNull-7">(3)</a> <a href="#ref-for-TreatNonObjectAsNull-8">(4)</a> <a href="#ref-for-TreatNonObjectAsNull-9">(5)</a>
<li><a href="#ref-for-TreatNonObjectAsNull-10">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="TreatNullAs">
<b><a href="#TreatNullAs">#TreatNullAs</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-TreatNullAs-1">2.2.2. Attributes</a>
<li><a href="#ref-for-TreatNullAs-2">2.2.3. Operations</a> <a href="#ref-for-TreatNullAs-3">(2)</a>
<li><a href="#ref-for-TreatNullAs-4">3.2.16. DOMString</a> <a href="#ref-for-TreatNullAs-5">(2)</a> <a href="#ref-for-TreatNullAs-6">(3)</a> <a href="#ref-for-TreatNullAs-7">(4)</a>
<li><a href="#ref-for-TreatNullAs-8">3.3.19. [TreatNullAs]</a> <a href="#ref-for-TreatNullAs-9">(2)</a> <a href="#ref-for-TreatNullAs-10">(3)</a> <a href="#ref-for-TreatNullAs-11">(4)</a> <a href="#ref-for-TreatNullAs-12">(5)</a> <a href="#ref-for-TreatNullAs-13">(6)</a> <a href="#ref-for-TreatNullAs-14">(7)</a> <a href="#ref-for-TreatNullAs-15">(8)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Unforgeable">
<b><a href="#Unforgeable">#Unforgeable</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Unforgeable-1">2.2. Interfaces</a> <a href="#ref-for-Unforgeable-2">(2)</a>
<li><a href="#ref-for-Unforgeable-3">2.2.2. Attributes</a>
<li><a href="#ref-for-Unforgeable-4">2.2.3. Operations</a>
<li><a href="#ref-for-Unforgeable-5">3.3.20. [Unforgeable]</a> <a href="#ref-for-Unforgeable-6">(2)</a> <a href="#ref-for-Unforgeable-7">(3)</a> <a href="#ref-for-Unforgeable-8">(4)</a> <a href="#ref-for-Unforgeable-9">(5)</a> <a href="#ref-for-Unforgeable-10">(6)</a> <a href="#ref-for-Unforgeable-11">(7)</a> <a href="#ref-for-Unforgeable-12">(8)</a> <a href="#ref-for-Unforgeable-13">(9)</a>
<li><a href="#ref-for-Unforgeable-14">3.6.6. Attributes</a>
<li><a href="#ref-for-Unforgeable-15">3.8. Platform objects implementing interfaces</a> <a href="#ref-for-Unforgeable-16">(2)</a> <a href="#ref-for-Unforgeable-17">(3)</a>
<li><a href="#ref-for-Unforgeable-18">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-unforgeable-on-an-interface">
<b><a href="#dfn-unforgeable-on-an-interface">#dfn-unforgeable-on-an-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-unforgeable-on-an-interface-1">3.3.20. [Unforgeable]</a>
<li><a href="#ref-for-dfn-unforgeable-on-an-interface-2">3.6.6. Attributes</a>
<li><a href="#ref-for-dfn-unforgeable-on-an-interface-3">3.6.7. Operations</a> <a href="#ref-for-dfn-unforgeable-on-an-interface-4">(2)</a>
<li><a href="#ref-for-dfn-unforgeable-on-an-interface-5">3.6.7.1. Stringifiers</a> <a href="#ref-for-dfn-unforgeable-on-an-interface-6">(2)</a>
<li><a href="#ref-for-dfn-unforgeable-on-an-interface-7">3.8. Platform objects implementing interfaces</a> <a href="#ref-for-dfn-unforgeable-on-an-interface-8">(2)</a>
<li><a href="#ref-for-dfn-unforgeable-on-an-interface-9">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Unscopable">
<b><a href="#Unscopable">#Unscopable</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Unscopable-1">3.3.21. [Unscopable]</a> <a href="#ref-for-Unscopable-2">(2)</a> <a href="#ref-for-Unscopable-3">(3)</a> <a href="#ref-for-Unscopable-4">(4)</a>
<li><a href="#ref-for-Unscopable-5">3.6.3. Interface prototype object</a> <a href="#ref-for-Unscopable-6">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-perform-a-security-check">
<b><a href="#dfn-perform-a-security-check">#dfn-perform-a-security-check</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-perform-a-security-check-1">3.6.6. Attributes</a> <a href="#ref-for-dfn-perform-a-security-check-2">(2)</a>
<li><a href="#ref-for-dfn-perform-a-security-check-3">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-perform-a-security-check-4">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-perform-a-security-check-5">3.6.7.2. Serializers</a>
<li><a href="#ref-for-dfn-perform-a-security-check-6">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-perform-a-security-check-7">(2)</a>
<li><a href="#ref-for-dfn-perform-a-security-check-8">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-perform-a-security-check-9">3.6.9.2. keys</a>
<li><a href="#ref-for-dfn-perform-a-security-check-10">3.6.9.3. values</a>
<li><a href="#ref-for-dfn-perform-a-security-check-11">3.6.9.5. Iterator prototype object</a>
<li><a href="#ref-for-dfn-perform-a-security-check-12">3.6.10. Maplike declarations</a>
<li><a href="#ref-for-dfn-perform-a-security-check-13">3.6.10.1. size</a>
<li><a href="#ref-for-dfn-perform-a-security-check-14">3.6.10.4. get and has</a>
<li><a href="#ref-for-dfn-perform-a-security-check-15">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-perform-a-security-check-16">3.6.10.7. set</a>
<li><a href="#ref-for-dfn-perform-a-security-check-17">3.6.11. Setlike declarations</a>
<li><a href="#ref-for-dfn-perform-a-security-check-18">3.6.11.1. size</a>
<li><a href="#ref-for-dfn-perform-a-security-check-19">3.6.11.4. has</a>
<li><a href="#ref-for-dfn-perform-a-security-check-20">3.6.11.5. add and delete</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-overload-resolution-algorithm">
<b><a href="#dfn-overload-resolution-algorithm">#dfn-overload-resolution-algorithm</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-overload-resolution-algorithm-1">3.6.1.1. Interface object [[Call]] method</a>
<li><a href="#ref-for-dfn-overload-resolution-algorithm-2">3.6.2. Named constructors</a>
<li><a href="#ref-for-dfn-overload-resolution-algorithm-3">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-overload-resolution-algorithm-4">3.8.9. Platform object [[Call]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-interface-object">
<b><a href="#dfn-interface-object">#dfn-interface-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-interface-object-1">2.2.5. Static attributes and operations</a>
<li><a href="#ref-for-dfn-interface-object-2">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-interface-object-3">3.3.2. [Constructor]</a>
<li><a href="#ref-for-dfn-interface-object-4">3.3.10. [NamedConstructor]</a>
<li><a href="#ref-for-dfn-interface-object-5">3.3.12. [NoInterfaceObject]</a> <a href="#ref-for-dfn-interface-object-6">(2)</a>
<li><a href="#ref-for-dfn-interface-object-7">3.6.1.1. Interface object [[Call]] method</a> <a href="#ref-for-dfn-interface-object-8">(2)</a>
<li><a href="#ref-for-dfn-interface-object-9">3.6.1.2. Interface object [[HasInstance]] method</a>
<li><a href="#ref-for-dfn-interface-object-10">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-interface-object-11">(2)</a>
<li><a href="#ref-for-dfn-interface-object-12">3.6.5. Constants</a>
<li><a href="#ref-for-dfn-interface-object-13">3.6.6. Attributes</a>
<li><a href="#ref-for-dfn-interface-object-14">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-interface-object-15">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-constructor">
<b><a href="#dfn-named-constructor">#dfn-named-constructor</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-constructor-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-named-constructor-2">3.6.2. Named constructors</a> <a href="#ref-for-dfn-named-constructor-3">(2)</a> <a href="#ref-for-dfn-named-constructor-4">(3)</a>
<li><a href="#ref-for-dfn-named-constructor-5">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-interface-prototype-object">
<b><a href="#dfn-interface-prototype-object">#dfn-interface-prototype-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-interface-prototype-object-1">2.2.7. Iterable declarations</a> <a href="#ref-for-dfn-interface-prototype-object-2">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-3">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-interface-prototype-object-4">3.3.5. [Global] and [PrimaryGlobal]</a>
<li><a href="#ref-for-dfn-interface-prototype-object-5">3.3.6. [LegacyArrayClass]</a>
<li><a href="#ref-for-dfn-interface-prototype-object-6">3.3.15. [Replaceable]</a>
<li><a href="#ref-for-dfn-interface-prototype-object-7">3.3.21. [Unscopable]</a>
<li><a href="#ref-for-dfn-interface-prototype-object-8">3.6.1.2. Interface object [[HasInstance]] method</a>
<li><a href="#ref-for-dfn-interface-prototype-object-9">3.6.2. Named constructors</a>
<li><a href="#ref-for-dfn-interface-prototype-object-10">3.6.3. Interface prototype object</a> <a href="#ref-for-dfn-interface-prototype-object-11">(2)</a> <a href="#ref-for-dfn-interface-prototype-object-12">(3)</a> <a href="#ref-for-dfn-interface-prototype-object-13">(4)</a> <a href="#ref-for-dfn-interface-prototype-object-14">(5)</a> <a href="#ref-for-dfn-interface-prototype-object-15">(6)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-16">3.6.4. Named properties object</a>
<li><a href="#ref-for-dfn-interface-prototype-object-17">3.6.5. Constants</a> <a href="#ref-for-dfn-interface-prototype-object-18">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-19">3.6.6. Attributes</a> <a href="#ref-for-dfn-interface-prototype-object-20">(2)</a> <a href="#ref-for-dfn-interface-prototype-object-21">(3)</a> <a href="#ref-for-dfn-interface-prototype-object-22">(4)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-23">3.6.7. Operations</a> <a href="#ref-for-dfn-interface-prototype-object-24">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-25">3.6.7.1. Stringifiers</a>
<li><a href="#ref-for-dfn-interface-prototype-object-26">3.6.7.2. Serializers</a> <a href="#ref-for-dfn-interface-prototype-object-27">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-28">3.6.8.1. @@iterator</a> <a href="#ref-for-dfn-interface-prototype-object-29">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-30">3.6.8.2. forEach</a> <a href="#ref-for-dfn-interface-prototype-object-31">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-32">3.6.9.1. entries</a> <a href="#ref-for-dfn-interface-prototype-object-33">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-34">3.6.9.2. keys</a> <a href="#ref-for-dfn-interface-prototype-object-35">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-36">3.6.9.3. values</a> <a href="#ref-for-dfn-interface-prototype-object-37">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-38">3.6.10. Maplike declarations</a>
<li><a href="#ref-for-dfn-interface-prototype-object-39">3.6.10.1. size</a>
<li><a href="#ref-for-dfn-interface-prototype-object-40">3.6.10.2. entries</a>
<li><a href="#ref-for-dfn-interface-prototype-object-41">3.6.10.3. keys and values</a>
<li><a href="#ref-for-dfn-interface-prototype-object-42">3.6.10.4. get and has</a>
<li><a href="#ref-for-dfn-interface-prototype-object-43">3.6.10.5. clear</a>
<li><a href="#ref-for-dfn-interface-prototype-object-44">3.6.10.6. delete</a>
<li><a href="#ref-for-dfn-interface-prototype-object-45">3.6.10.7. set</a>
<li><a href="#ref-for-dfn-interface-prototype-object-46">3.6.11. Setlike declarations</a>
<li><a href="#ref-for-dfn-interface-prototype-object-47">3.6.11.1. size</a>
<li><a href="#ref-for-dfn-interface-prototype-object-48">3.6.11.2. values</a>
<li><a href="#ref-for-dfn-interface-prototype-object-49">3.6.11.3. entries and keys</a>
<li><a href="#ref-for-dfn-interface-prototype-object-50">3.6.11.4. has</a>
<li><a href="#ref-for-dfn-interface-prototype-object-51">3.6.11.5. add and delete</a>
<li><a href="#ref-for-dfn-interface-prototype-object-52">3.6.11.6. clear</a>
<li><a href="#ref-for-dfn-interface-prototype-object-53">3.7. Implements statements</a> <a href="#ref-for-dfn-interface-prototype-object-54">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-55">3.8. Platform objects implementing interfaces</a> <a href="#ref-for-dfn-interface-prototype-object-56">(2)</a>
<li><a href="#ref-for-dfn-interface-prototype-object-57">3.8.1. Indexed and named properties</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-properties-object">
<b><a href="#dfn-named-properties-object">#dfn-named-properties-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-properties-object-1">3.1. ECMAScript environment</a> <a href="#ref-for-dfn-named-properties-object-2">(2)</a>
<li><a href="#ref-for-dfn-named-properties-object-3">3.3.5. [Global] and [PrimaryGlobal]</a> <a href="#ref-for-dfn-named-properties-object-4">(2)</a>
<li><a href="#ref-for-dfn-named-properties-object-5">3.6.3. Interface prototype object</a>
<li><a href="#ref-for-dfn-named-properties-object-6">3.6.4. Named properties object</a> <a href="#ref-for-dfn-named-properties-object-7">(2)</a>
<li><a href="#ref-for-dfn-named-properties-object-8">3.6.4.1. Named properties object [[GetOwnProperty]] method</a> <a href="#ref-for-dfn-named-properties-object-9">(2)</a>
<li><a href="#ref-for-dfn-named-properties-object-10">3.6.4.2. Named properties object [[DefineOwnProperty]] method</a>
<li><a href="#ref-for-dfn-named-properties-object-11">3.6.4.3. Named properties object [[Delete]] method</a>
<li><a href="#ref-for-dfn-named-properties-object-12">3.6.4.4. Named properties object [[SetPrototypeOf]] method</a>
<li><a href="#ref-for-dfn-named-properties-object-13">3.8.1. Indexed and named properties</a> <a href="#ref-for-dfn-named-properties-object-14">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-attribute-getter">
<b><a href="#dfn-attribute-getter">#dfn-attribute-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-attribute-getter-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-attribute-getter-2">3.6.6. Attributes</a> <a href="#ref-for-dfn-attribute-getter-3">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-attribute-setter">
<b><a href="#dfn-attribute-setter">#dfn-attribute-setter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-attribute-setter-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-attribute-setter-2">3.6.6. Attributes</a> <a href="#ref-for-dfn-attribute-setter-3">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-create-operation-function">
<b><a href="#dfn-create-operation-function">#dfn-create-operation-function</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-create-operation-function-1">3.6.7. Operations</a>
<li><a href="#ref-for-dfn-create-operation-function-2">3.11.1. Namespace object</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-convert-serialized-value-to-ecmascript-value">
<b><a href="#dfn-convert-serialized-value-to-ecmascript-value">#dfn-convert-serialized-value-to-ecmascript-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-convert-serialized-value-to-ecmascript-value-1">3.6.7.2. Serializers</a> <a href="#ref-for-dfn-convert-serialized-value-to-ecmascript-value-2">(2)</a> <a href="#ref-for-dfn-convert-serialized-value-to-ecmascript-value-3">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-default-iterator-object">
<b><a href="#dfn-default-iterator-object">#dfn-default-iterator-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-default-iterator-object-1">3.6.8.1. @@iterator</a>
<li><a href="#ref-for-dfn-default-iterator-object-2">3.6.9.2. keys</a>
<li><a href="#ref-for-dfn-default-iterator-object-3">3.6.9.3. values</a>
<li><a href="#ref-for-dfn-default-iterator-object-4">3.6.9.4. Default iterator objects</a> <a href="#ref-for-dfn-default-iterator-object-5">(2)</a> <a href="#ref-for-dfn-default-iterator-object-6">(3)</a>
<li><a href="#ref-for-dfn-default-iterator-object-7">3.6.9.5. Iterator prototype object</a> <a href="#ref-for-dfn-default-iterator-object-8">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-iterator-prototype-object">
<b><a href="#dfn-iterator-prototype-object">#dfn-iterator-prototype-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-iterator-prototype-object-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-iterator-prototype-object-2">3.6.9.4. Default iterator objects</a>
<li><a href="#ref-for-dfn-iterator-prototype-object-3">3.6.9.5. Iterator prototype object</a> <a href="#ref-for-dfn-iterator-prototype-object-4">(2)</a> <a href="#ref-for-dfn-iterator-prototype-object-5">(3)</a> <a href="#ref-for-dfn-iterator-prototype-object-6">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-forwards-to-the-internal-map-object">
<b><a href="#dfn-forwards-to-the-internal-map-object">#dfn-forwards-to-the-internal-map-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-forwards-to-the-internal-map-object-1">3.6.10.3. keys and values</a>
<li><a href="#ref-for-dfn-forwards-to-the-internal-map-object-2">3.6.10.5. clear</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-map-size-getter">
<b><a href="#dfn-map-size-getter">#dfn-map-size-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-map-size-getter-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-map-size-getter-2">3.6.10.1. size</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-forwards-to-the-internal-set-object">
<b><a href="#dfn-forwards-to-the-internal-set-object">#dfn-forwards-to-the-internal-set-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-forwards-to-the-internal-set-object-1">3.6.11.3. entries and keys</a>
<li><a href="#ref-for-dfn-forwards-to-the-internal-set-object-2">3.6.11.6. clear</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-set-size-getter">
<b><a href="#dfn-set-size-getter">#dfn-set-size-getter</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-set-size-getter-1">3.6.11.1. size</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-primary-interface">
<b><a href="#dfn-primary-interface">#dfn-primary-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-primary-interface-1">3.8. Platform objects implementing interfaces</a> <a href="#ref-for-dfn-primary-interface-2">(2)</a> <a href="#ref-for-dfn-primary-interface-3">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-default-unforgeable-valueOf-function">
<b><a href="#dfn-default-unforgeable-valueOf-function">#dfn-default-unforgeable-valueOf-function</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-default-unforgeable-valueOf-function-1">3.1. ECMAScript environment</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-array-index-property-name">
<b><a href="#dfn-array-index-property-name">#dfn-array-index-property-name</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-array-index-property-name-1">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-array-index-property-name-2">3.8.6. Platform object [[Set]] method</a> <a href="#ref-for-dfn-array-index-property-name-3">(2)</a>
<li><a href="#ref-for-dfn-array-index-property-name-4">3.8.7. Platform object [[DefineOwnProperty]] method</a>
<li><a href="#ref-for-dfn-array-index-property-name-5">3.8.8. Platform object [[Delete]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-unforgeable-property-name">
<b><a href="#dfn-unforgeable-property-name">#dfn-unforgeable-property-name</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-unforgeable-property-name-1">3.8.1. Indexed and named properties</a>
<li><a href="#ref-for-dfn-unforgeable-property-name-2">3.8.7. Platform object [[DefineOwnProperty]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-named-property-visibility">
<b><a href="#dfn-named-property-visibility">#dfn-named-property-visibility</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-named-property-visibility-1">3.6.4.1. Named properties object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-dfn-named-property-visibility-2">3.8.2. The PlatformObjectGetOwnProperty abstract operation</a>
<li><a href="#ref-for-dfn-named-property-visibility-3">3.8.8. Platform object [[Delete]] method</a>
<li><a href="#ref-for-dfn-named-property-visibility-4">3.8.10. Property enumeration</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="getownproperty-guts">
<b><a href="#getownproperty-guts">#getownproperty-guts</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-getownproperty-guts-1">3.8.3. Platform object [[GetOwnProperty]] method</a>
<li><a href="#ref-for-getownproperty-guts-2">3.8.6. Platform object [[Set]] method</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-single-operation-callback-interface">
<b><a href="#dfn-single-operation-callback-interface">#dfn-single-operation-callback-interface</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-single-operation-callback-interface-1">3.9. User objects implementing callback interfaces</a> <a href="#ref-for-dfn-single-operation-callback-interface-2">(2)</a> <a href="#ref-for-dfn-single-operation-callback-interface-3">(3)</a> <a href="#ref-for-dfn-single-operation-callback-interface-4">(4)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-callback-this-value">
<b><a href="#dfn-callback-this-value">#dfn-callback-this-value</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-callback-this-value-1">3.6.8.2. forEach</a>
<li><a href="#ref-for-dfn-callback-this-value-2">3.10. Invoking callback functions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-DOMException-constructor-object">
<b><a href="#dfn-DOMException-constructor-object">#dfn-DOMException-constructor-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-DOMException-constructor-object-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-DOMException-constructor-object-2">3.12.2. DOMException prototype object</a>
<li><a href="#ref-for-dfn-DOMException-constructor-object-3">3.13. Exception objects</a> <a href="#ref-for-dfn-DOMException-constructor-object-4">(2)</a>
<li><a href="#ref-for-dfn-DOMException-constructor-object-5">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-DOMException-prototype-object">
<b><a href="#dfn-DOMException-prototype-object">#dfn-DOMException-prototype-object</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-DOMException-prototype-object-1">3.1. ECMAScript environment</a>
<li><a href="#ref-for-dfn-DOMException-prototype-object-2">3.12.2. DOMException prototype object</a>
<li><a href="#ref-for-dfn-DOMException-prototype-object-3">3.13. Exception objects</a> <a href="#ref-for-dfn-DOMException-prototype-object-4">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="es-exception-objects">
<b><a href="#es-exception-objects">#es-exception-objects</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-es-exception-objects-1">3.8.10. Property enumeration</a>
<li><a href="#ref-for-es-exception-objects-2">3.14. Creating and throwing exceptions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-current-global-environment">
<b><a href="#dfn-current-global-environment">#dfn-current-global-environment</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-current-global-environment-1">3.2.29. RegExp</a>
<li><a href="#ref-for-dfn-current-global-environment-2">3.14. Creating and throwing exceptions</a> <a href="#ref-for-dfn-current-global-environment-3">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="ArrayBufferView">
<b><a href="#ArrayBufferView">#ArrayBufferView</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-ArrayBufferView-1">4.1. ArrayBufferView</a> <a href="#ref-for-ArrayBufferView-2">(2)</a>
<li><a href="#ref-for-ArrayBufferView-3">4.2. BufferSource</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="BufferSource">
<b><a href="#BufferSource">#BufferSource</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-BufferSource-1">2.11.31. Buffer source types</a>
<li><a href="#ref-for-BufferSource-2">4.2. BufferSource</a> <a href="#ref-for-BufferSource-3">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="DOMTimeStamp">
<b><a href="#DOMTimeStamp">#DOMTimeStamp</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-DOMTimeStamp-1">4.3. DOMTimeStamp</a> <a href="#ref-for-DOMTimeStamp-2">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="Function">
<b><a href="#Function">#Function</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-Function-1">4.4. Function</a> <a href="#ref-for-Function-2">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="VoidFunction">
<b><a href="#VoidFunction">#VoidFunction</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-VoidFunction-1">4.5. VoidFunction</a> <a href="#ref-for-VoidFunction-2">(2)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-example-term">
<b><a href="#dfn-example-term">#dfn-example-term</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-example-term-1">Document conventions</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-conforming-set-of-idl-fragments">
<b><a href="#dfn-conforming-set-of-idl-fragments">#dfn-conforming-set-of-idl-fragments</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-conforming-set-of-idl-fragments-1">Conformance</a> <a href="#ref-for-dfn-conforming-set-of-idl-fragments-2">(2)</a> <a href="#ref-for-dfn-conforming-set-of-idl-fragments-3">(3)</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-conforming-implementation">
<b><a href="#dfn-conforming-implementation">#dfn-conforming-implementation</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-conforming-implementation-1">4. Common definitions</a>
<li><a href="#ref-for-dfn-conforming-implementation-2">6. Referencing this specification</a>
<li><a href="#ref-for-dfn-conforming-implementation-3">Conformance</a>
</ul>
</aside>
<aside class="dfn-panel" data-for="dfn-conforming-ecmascript-implementation">
<b><a href="#dfn-conforming-ecmascript-implementation">#dfn-conforming-ecmascript-implementation</a></b><b>Referenced in:</b>
<ul>
<li><a href="#ref-for-dfn-conforming-ecmascript-implementation-1">Conformance</a>
</ul>
</aside>
<script>/* script-dfn-panel */
document.body.addEventListener("click", function(e) {
var queryAll = function(sel) { return [].slice.call(document.querySelectorAll(sel)); }
// Find the dfn element or panel, if any, that was clicked on.
var el = e.target;
var target;
var hitALink = false;
while(el.parentElement) {
if(el.tagName == "A") {
// Clicking on a link in a <dfn> shouldn't summon the panel
hitALink = true;
}
if(el.classList.contains("dfn-paneled")) {
target = "dfn";
break;
}
if(el.classList.contains("dfn-panel")) {
target = "dfn-panel";
break;
}
el = el.parentElement;
}
if(target != "dfn-panel") {
// Turn off any currently "on" or "activated" panels.
queryAll(".dfn-panel.on, .dfn-panel.activated").forEach(function(el){
el.classList.remove("on");
el.classList.remove("activated");
});
}
if(target == "dfn" && !hitALink) {
// open the panel
var dfnPanel = document.querySelector(".dfn-panel[data-for='" + el.id + "']");
if(dfnPanel) {
console.log(dfnPanel);
dfnPanel.classList.add("on");
var rect = el.getBoundingClientRect();
dfnPanel.style.left = window.scrollX + rect.right + 5 + "px";
dfnPanel.style.top = window.scrollY + rect.top + "px";
var panelRect = dfnPanel.getBoundingClientRect();
var panelWidth = panelRect.right - panelRect.left;
if(panelRect.right > document.body.scrollWidth && (rect.left - (panelWidth + 5)) > 0) {
// Reposition, because the panel is overflowing
dfnPanel.style.left = window.scrollX + rect.left - (panelWidth + 5) + "px";
}
} else {
console.log("Couldn't find .dfn-panel[data-for='" + el.id + "']");
}
} else if(target == "dfn-panel") {
// Switch it to "activated" state, which pins it.
el.classList.add("activated");
el.style.left = null;
el.style.top = null;
}
});
</script>