BVB Source Codes

ecma262 Show spec.html Source code

Return Download ecma262: download spec.html Source code - Download ecma262 Source code - Type:.html
  1. <!DOCTYPE html>
  2. <meta charset="ascii">
  3. <link rel="icon" href="img/favicon.ico">
  4. <link href="ecmarkup.css" rel="stylesheet">
  5. <link rel="stylesheet" href="">
  6. <script src="ecmarkup.js"></script>
  7. <script>
  8.   if (location.hostname === '' && location.protocol !== 'https:') {
  9.    location.protocol = 'https:';
  10.   }
  11. </script>
  12. <pre class=metadata>
  13.   title: ECMAScript&reg; 2017 Language Specification
  14.   shortname: ECMA-262
  15.   status: draft
  16.   location:
  17. </pre>
  18. <emu-intro id="sec-intro">
  19.   <h1>Introduction</h1>
  20.   <p>This Ecma Standard defines the ECMAScript 2017 Language. It is the eighth edition of the ECMAScript Language Specification. Since publication of the first edition in 1997, ECMAScript has grown to be one of the world's most widely used general-purpose programming languages. It is best known as the language embedded in web browsers but has also been widely adopted for server and embedded applications.</p>
  21.   <p>ECMAScript is based on several originating technologies, the most well-known being JavaScript (Netscape) and JScript (Microsoft). The language was invented by Brendan Eich at Netscape and first appeared in that company's Navigator 2.0 browser. It has appeared in all subsequent browsers from Netscape and in all browsers from Microsoft starting with Internet Explorer 3.0.</p>
  22.   <p>The development of the ECMAScript Language Specification started in November 1996. The first edition of this Ecma Standard was adopted by the Ecma General Assembly of June 1997.</p>
  23.   <p>That Ecma Standard was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262, in April 1998. The Ecma General Assembly of June 1998 approved the second edition of ECMA-262 to keep it fully aligned with ISO/IEC 16262. Changes between the first and the second edition are editorial in nature.</p>
  24.   <p>The third edition of the Standard introduced powerful regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and minor changes in anticipation of future language growth. The third edition of the ECMAScript standard was adopted by the Ecma General Assembly of December 1999 and published as ISO/IEC 16262:2002 in June 2002.</p>
  25.   <p>After publication of the third edition, ECMAScript achieved massive adoption in conjunction with the World Wide Web where it has become the programming language that is supported by essentially all web browsers. Significant work was done to develop a fourth edition of ECMAScript. However, that work was not completed and not published as the fourth edition of ECMAScript but some of it was incorporated into the development of the sixth edition.</p>
  26.   <p>The fifth edition of ECMAScript (published as ECMA-262 5<sup>th</sup> edition) codified de facto interpretations of the language specification that have become common among browser implementations and added support for new features that had emerged since the publication of the third edition. Such features include accessor properties, reflective creation and inspection of objects, program control of property attributes, additional array manipulation functions, support for the JSON object encoding format, and a strict mode that provides enhanced error checking and program security. The Fifth Edition was adopted by the Ecma General Assembly of December 2009.</p>
  27.   <p>The fifth Edition was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262:2011. Edition 5.1 of the ECMAScript Standard incorporated minor corrections and is the same text as ISO/IEC 16262:2011. The 5.1 Edition was adopted by the Ecma General Assembly of June 2011.</p>
  28.   <p>Focused development of the sixth edition started in 2009, as the fifth edition was being prepared for publication. However, this was preceded by significant experimentation and language enhancement design efforts dating to the publication of the third edition in 1999. In a very real sense, the completion of the sixth edition is the culmination of a fifteen year effort. The goals for this addition included providing better support for large applications, library creation, and for use of ECMAScript as a compilation target for other languages. Some of its major enhancements included modules, class declarations, lexical block scoping, iterators and generators, promises for asynchronous programming, destructuring patterns, and proper tail calls. The ECMAScript library of built-ins was expanded to support additional data abstractions including maps, sets, and arrays of binary numeric values as well as additional support for Unicode supplemental characters in strings and regular expressions. The built-ins were also made extensible via subclassing. The sixth edition provides the foundation for regular, incremental language and library enhancements. The sixth edition was adopted by the General Assembly of June 2015.</p>
  29.   <p>This ECMAScript specification is the first ECMAScript edition released under Ecma TC39's new yearly release cadence and open development process. A plain-text source document was built from the ECMAScript 2015 source document to serve as the base for further development entirely on GitHub. Over the year of this standard's development, hundreds of pull requests and issues were filed representing thousands of bug fixes, editorial fixes and other improvements. Additionally, numerous software tools were developed to aid in this effort including Ecmarkup, Ecmarkdown, and Grammarkdown. This specification also includes support for a new exponentiation operator and adds a new method to Array.prototype called `includes`.</p>
  30.   <p>Dozens of individuals representing many organizations have made very significant contributions within Ecma TC39 to the development of this edition and to the prior editions. In addition, a vibrant community has emerged supporting TC39's ECMAScript efforts. This community has reviewed numerous drafts, filed thousands of bug reports, performed implementation experiments, contributed test suites, and educated the world-wide developer community about ECMAScript. Unfortunately, it is impossible to identify and acknowledge every person and organization who has contributed to this effort.</p>
  31.   <p>
  32.     Allen Wirfs-Brock<br>
  33.     ECMA-262, 6<sup>th</sup> Edition Project Editor
  34.   </p>
  35.   <p>
  36.     Brian Terlson<br>
  37.     ECMA-262, 7<sup>th</sup> Edition Project Editor
  38.   </p>
  39. </emu-intro>
  41. <!-- es6num="1" -->
  42. <emu-clause id="sec-scope">
  43.   <h1>Scope</h1>
  44.   <p>This Standard defines the ECMAScript 2017 general-purpose programming language.</p>
  45. </emu-clause>
  47. <!-- es6num="2" -->
  48. <emu-clause id="sec-conformance">
  49.   <h1>Conformance</h1>
  50.   <p>A conforming implementation of ECMAScript must provide and support all the types, values, objects, properties, functions, and program syntax and semantics described in this specification.</p>
  51.   <p>A conforming implementation of ECMAScript must interpret source text input in conformance with the latest version of the Unicode Standard and ISO/IEC 10646.</p>
  52.   <p>A conforming implementation of ECMAScript that provides an application programming interface that supports programs that need to adapt to the linguistic and cultural conventions used by different human languages and countries must implement the interface defined by the most recent edition of ECMA-402 that is compatible with this specification.</p>
  53.   <p>A conforming implementation of ECMAScript may provide additional types, values, objects, properties, and functions beyond those described in this specification. In particular, a conforming implementation of ECMAScript may provide properties not described in this specification, and values for those properties, for objects that are described in this specification.</p>
  54.   <p>A conforming implementation of ECMAScript may support program and regular expression syntax not described in this specification. In particular, a conforming implementation of ECMAScript may support program syntax that makes use of the &ldquo;future reserved words&rdquo; listed in subclause <emu-xref href="#sec-future-reserved-words"></emu-xref> of this specification.</p>
  55.   <p>A conforming implementation of ECMAScript must not implement any extension that is listed as a Forbidden Extension in subclause <emu-xref href="#sec-forbidden-extensions"></emu-xref>.</p>
  56. </emu-clause>
  58. <!-- es6num="3" -->
  59. <emu-clause id="sec-normative-references">
  60.   <h1>Normative References</h1>
  61.   <p>The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.</p>
  62.   <p>ISO/IEC 10646:2003: <i>Information Technology &ndash; Universal Multiple-Octet Coded Character Set (UCS) plus Amendment 1:2005, Amendment 2:2006, Amendment 3:2008, and Amendment 4:2008</i>, plus additional amendments and corrigenda, or successor</p>
  63.   <p>ECMA-402, <i>ECMAScript 2015 Internationalization API Specification</i>.
  64.     <br>
  65.     <a href=""></a></p>
  66.   <p>ECMA-404, <i>The JSON Data Interchange Format</i>.
  67.     <br>
  68.     <a href=""></a></p>
  69. </emu-clause>
  71. <!-- es6num="4" -->
  72. <emu-clause id="sec-overview">
  73.   <h1>Overview</h1>
  74.   <p>This section contains a non-normative overview of the ECMAScript language.</p>
  75.   <p>ECMAScript is an object-oriented programming language for performing computations and manipulating computational objects within a host environment. ECMAScript as defined here is not intended to be computationally self-sufficient; indeed, there are no provisions in this specification for input of external data or output of computed results. Instead, it is expected that the computational environment of an ECMAScript program will provide not only the objects and other facilities described in this specification but also certain environment-specific objects, whose description and behaviour are beyond the scope of this specification except to indicate that they may provide certain properties that can be accessed and certain functions that can be called from an ECMAScript program.</p>
  76.   <p>ECMAScript was originally designed to be used as a scripting language, but has become widely used as a general-purpose programming language. A <em>scripting language</em> is a programming language that is used to manipulate, customize, and automate the facilities of an existing system. In such systems, useful functionality is already available through a user interface, and the scripting language is a mechanism for exposing that functionality to program control. In this way, the existing system is said to provide a host environment of objects and facilities, which completes the capabilities of the scripting language. A scripting language is intended for use by both professional and non-professional programmers.</p>
  77.   <p>ECMAScript was originally designed to be a <em>Web scripting language</em>, providing a mechanism to enliven Web pages in browsers and to perform server computation as part of a Web-based client-server architecture. ECMAScript is now used to provide core scripting capabilities for a variety of host environments. Therefore the core language is specified in this document apart from any particular host environment.</p>
  78.   <p>ECMAScript usage has moved beyond simple scripting and it is now used for the full spectrum of programming tasks in many different environments and scales. As the usage of ECMAScript has expanded, so has the features and facilities it provides. ECMAScript is now a fully featured general-purpose programming language.</p>
  79.   <p>Some of the facilities of ECMAScript are similar to those used in other programming languages; in particular C, Java&trade;, Self, and Scheme as described in:</p>
  80.   <p>ISO/IEC 9899:1996, <i>Programming Languages &ndash; C</i>.</p>
  81.   <p>Gosling, James, Bill Joy and Guy Steele. <i>The Java<sup>&trade;</sup> Language Specification</i>. Addison Wesley Publishing Co., 1996.</p>
  82.   <p>Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. <i>OOPSLA '87 Conference Proceedings</i>, pp. 227-241, Orlando, FL, October 1987.</p>
  83.   <p><i>IEEE Standard for the Scheme Programming Language</i>. IEEE Std 1178-1990.</p>
  85.   <!-- es6num="4.1" -->
  86.   <emu-clause id="sec-web-scripting">
  87.     <h1>Web Scripting</h1>
  88.     <p>A web browser provides an ECMAScript host environment for client-side computation including, for instance, objects that represent windows, menus, pop-ups, dialog boxes, text areas, anchors, frames, history, cookies, and input/output. Further, the host environment provides a means to attach scripting code to events such as change of focus, page and image loading, unloading, error and abort, selection, form submission, and mouse actions. Scripting code appears within the HTML and the displayed page is a combination of user interface elements and fixed and computed text and images. The scripting code is reactive to user interaction and there is no need for a main program.</p>
  89.     <p>A web server provides a different host environment for server-side computation including objects representing requests, clients, and files; and mechanisms to lock and share data. By using browser-side and server-side scripting together, it is possible to distribute computation between the client and server while providing a customized user interface for a Web-based application.</p>
  90.     <p>Each Web browser and server that supports ECMAScript supplies its own host environment, completing the ECMAScript execution environment.</p>
  91.   </emu-clause>
  93.   <!-- es6num="4.2" -->
  94.   <emu-clause id="sec-ecmascript-overview">
  95.     <h1>ECMAScript Overview</h1>
  96.     <p>The following is an informal overview of ECMAScript&mdash;not all parts of the language are described. This overview is not part of the standard proper.</p>
  97.     <p>ECMAScript is object-based: basic language and host facilities are provided by objects, and an ECMAScript program is a cluster of communicating objects. In ECMAScript, an <em>object</em> is a collection of zero or more <em>properties</em> each with <em>attributes</em> that determine how each property can be used&mdash;for example, when the Writable attribute for a property is set to *false*, any attempt by executed ECMAScript code to assign a different value to the property fails. Properties are containers that hold other objects, <em>primitive values</em>, or <em>functions</em>. A primitive value is a member of one of the following built-in types: <b>Undefined</b>, <b>Null</b>, <b>Boolean</b>, <b>Number</b>, <b>String</b>, and <b>Symbol;</b> an object is a member of the built-in type <b>Object</b>; and a function is a callable object. A function that is associated with an object via a property is called a <em>method</em>.</p>
  98.     <p>ECMAScript defines a collection of <em>built-in objects</em> that round out the definition of ECMAScript entities. These built-in objects include the global object; objects that are fundamental to the runtime semantics of the language including `Object`, `Function`, `Boolean`, `Symbol`, and various `Error` objects; objects that represent and manipulate numeric values including `Math`, `Number`, and `Date`; the text processing objects `String` and `RegExp`; objects that are indexed collections of values including `Array` and nine different kinds of Typed Arrays whose elements all have a specific numeric data representation; keyed collections including `Map` and `Set` objects; objects supporting structured data including the `JSON` object, `ArrayBuffer`, and `DataView`; objects supporting control abstractions including generator functions and `Promise` objects; and, reflection objects including `Proxy` and `Reflect`.</p>
  99.     <p>ECMAScript also defines a set of built-in <em>operators</em>. ECMAScript operators include various unary operations, multiplicative operators, additive operators, bitwise shift operators, relational operators, equality operators, binary bitwise operators, binary logical operators, assignment operators, and the comma operator.</p>
  100.     <p>Large ECMAScript programs are supported by <em>modules</em> which allow a program to be divided into multiple sequences of statements and declarations. Each module explicitly identifies declarations it uses that need to be provided by other modules and which of its declarations are available for use by other modules.</p>
  101.     <p>ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to serve as an easy-to-use scripting language. For example, a variable is not required to have its type declared nor are types associated with properties, and defined functions are not required to have their declarations appear textually before calls to them.</p>
  103.     <!-- es6num="4.2.1" -->
  104.     <emu-clause id="sec-objects">
  105.       <h1>Objects</h1>
  106.       <p>Even though ECMAScript includes syntax for class definitions, ECMAScript objects are not fundamentally class-based such as those in C++, Smalltalk, or Java. Instead objects may be created in various ways including via a literal notation or via <em>constructors</em> which create objects and then execute code that initializes all or part of them by assigning initial values to their properties. Each constructor is a function that has a property named `"prototype"` that is used to implement <em>prototype-based inheritance</em> and <em>shared properties</em>. Objects are created by using constructors in <b>new</b> expressions; for example, `new Date(2009,11)` creates a new Date object. Invoking a constructor without using <b>new</b> has consequences that depend on the constructor. For example, `Date()` produces a string representation of the current date and time rather than an object.</p>
  107.       <p>Every object created by a constructor has an implicit reference (called the object's <em>prototype</em>) to the value of its constructor's `"prototype"` property. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the <em>prototype chain</em>. When a reference is made to a property in an object, that reference is to the property of that name in the first object in the prototype chain that contains a property of that name. In other words, first the object mentioned directly is examined for such a property; if that object contains the named property, that is the property to which the reference refers; if that object does not contain the named property, the prototype for that object is examined next; and so on.</p>
  108.       <emu-figure id="figure-1" caption="Object/Prototype Relationships">
  109.         <object data="img/figure-1.svg" height="354" type="image/svg+xml" width="719"> <img alt="An image of lots of boxes and arrows." height="354" src="img/figure-1.png" width="719"> </object>
  110.       </emu-figure>
  111.       <p>In a class-based object-oriented language, in general, state is carried by instances, methods are carried by classes, and inheritance is only of structure and behaviour. In ECMAScript, the state and methods are carried by objects, while structure, behaviour, and state are all inherited.</p>
  112.       <p>All objects that do not directly contain a particular property that their prototype contains share that property and its value. Figure 1 illustrates this:</p>
  113.       <p><b>CF</b> is a constructor (and also an object). Five objects have been created by using `new` expressions: <b>cf<sub>1</sub></b>, <b>cf<sub>2</sub></b>, <b>cf<sub>3</sub></b>, <b>cf<sub>4</sub></b>, and <b>cf<sub>5</sub></b>. Each of these objects contains properties named `q1` and `q2`. The dashed lines represent the implicit prototype relationship; so, for example, <b>cf<sub>3</sub></b>'s prototype is <b>CF<sub>p</sub></b>. The constructor, <b>CF</b>, has two properties itself, named `P1` and `P2`, which are not visible to <b>CF<sub>p</sub></b>, <b>cf<sub>1</sub></b>, <b>cf<sub>2</sub></b>, <b>cf<sub>3</sub></b>, <b>cf<sub>4</sub></b>, or <b>cf<sub>5</sub></b>. The property named `CFP1` in <b>CF<sub>p</sub></b> is shared by <b>cf<sub>1</sub></b>, <b>cf<sub>2</sub></b>, <b>cf<sub>3</sub></b>, <b>cf<sub>4</sub></b>, and <b>cf<sub>5</sub></b> (but not by <b>CF</b>), as are any properties found in <b>CF<sub>p</sub></b>'s implicit prototype chain that are not named `q1`, `q2`, or `CFP1`. Notice that there is no implicit prototype link between <b>CF</b> and <b>CF<sub>p</sub></b>.</p>
  114.       <p>Unlike most class-based object languages, properties can be added to objects dynamically by assigning values to them. That is, constructors are not required to name or assign values to all or any of the constructed object's properties. In the above diagram, one could add a new shared property for <b>cf<sub>1</sub></b>, <b>cf<sub>2</sub></b>, <b>cf<sub>3</sub></b>, <b>cf<sub>4</sub></b>, and <b>cf<sub>5</sub></b> by assigning a new value to the property in <b>CF<sub>p</sub></b>.</p>
  115.       <p>Although ECMAScript objects are not inherently class-based, it is often convenient to define class-like abstractions based upon a common pattern of constructor functions, prototype objects, and methods. The ECMAScript built-in objects themselves follow such a class-like pattern. Beginning with ECMAScript 2015, the ECMAScript language includes syntactic class definitions that permit programmers to concisely define objects that conform to the same class-like abstraction pattern used by the built-in objects.</p>
  116.     </emu-clause>
  118.     <!-- es6num="4.2.2" -->
  119.     <emu-clause id="sec-strict-variant-of-ecmascript">
  120.       <h1>The Strict Variant of ECMAScript</h1>
  121.       <p>The ECMAScript Language recognizes the possibility that some users of the language may wish to restrict their usage of some features available in the language. They might do so in the interests of security, to avoid what they consider to be error-prone features, to get enhanced error checking, or for other reasons of their choosing. In support of this possibility, ECMAScript defines a strict variant of the language. The strict variant of the language excludes some specific syntactic and semantic features of the regular ECMAScript language and modifies the detailed semantics of some features. The strict variant also specifies additional error conditions that must be reported by throwing error exceptions in situations that are not specified as errors by the non-strict form of the language.</p>
  122.       <p>The strict variant of ECMAScript is commonly referred to as the <em>strict mode</em> of the language. Strict mode selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at the level of individual ECMAScript source text units. Because strict mode is selected at the level of a syntactic source text unit, strict mode only imposes restrictions that have local effect within such a source text unit. Strict mode does not restrict or modify any aspect of the ECMAScript semantics that must operate consistently across multiple source text units. A complete ECMAScript program may be composed of both strict mode and non-strict mode ECMAScript source text units. In this case, strict mode only applies when actually executing code that is defined within a strict mode source text unit.</p>
  123.       <p>In order to conform to this specification, an ECMAScript implementation must implement both the full unrestricted ECMAScript language and the strict variant of the ECMAScript language as defined by this specification. In addition, an implementation must support the combination of unrestricted and strict mode source text units into a single composite program.</p>
  124.     </emu-clause>
  125.   </emu-clause>
  127.   <!-- es6num="4.3" -->
  128.   <emu-clause id="sec-terms-and-definitions">
  129.     <h1>Terms and Definitions</h1>
  130.     <p>For the purposes of this document, the following terms and definitions apply.</p>
  132.     <!-- es6num="4.3.1" -->
  133.     <emu-clause id="sec-type">
  134.       <h1>type</h1>
  135.       <p>set of data values as defined in clause <emu-xref href="#sec-ecmascript-data-types-and-values"></emu-xref> of this specification</p>
  136.     </emu-clause>
  138.     <!-- es6num="4.3.2" -->
  139.     <emu-clause id="sec-primitive-value">
  140.       <h1>primitive value</h1>
  141.       <p>member of one of the types Undefined, Null, Boolean, Number, Symbol, or String as defined in clause <emu-xref href="#sec-ecmascript-data-types-and-values"></emu-xref></p>
  142.       <emu-note>
  143.         <p>A primitive value is a datum that is represented directly at the lowest level of the language implementation.</p>
  144.       </emu-note>
  145.     </emu-clause>
  147.     <!-- es6num="4.3.3" -->
  148.     <emu-clause id="sec-terms-and-definitions-object">
  149.       <h1>object</h1>
  150.       <p>member of the type Object</p>
  151.       <emu-note>
  152.         <p>An object is a collection of properties and has a single prototype object. The prototype may be the null value.</p>
  153.       </emu-note>
  154.     </emu-clause>
  156.     <!-- es6num="4.3.4" -->
  157.     <emu-clause id="sec-constructor">
  158.       <h1>constructor</h1>
  159.       <p>function object that creates and initializes objects</p>
  160.       <emu-note>
  161.         <p>The value of a constructor's `prototype` property is a prototype object that is used to implement inheritance and shared properties.</p>
  162.       </emu-note>
  163.     </emu-clause>
  165.     <!-- es6num="4.3.5" -->
  166.     <emu-clause id="sec-terms-and-definitions-prototype">
  167.       <h1>prototype</h1>
  168.       <p>object that provides shared properties for other objects</p>
  169.       <emu-note>
  170.         <p>When a constructor creates an object, that object implicitly references the constructor's `prototype` property for the purpose of resolving property references. The constructor's `prototype` property can be referenced by the program expression <code><var>constructor</var>.prototype</code>, and properties added to an object's prototype are shared, through inheritance, by all objects sharing the prototype. Alternatively, a new object may be created with an explicitly specified prototype by using the `Object.create` built-in function.</p>
  171.       </emu-note>
  172.     </emu-clause>
  174.     <!-- es6num="4.3.6" -->
  175.     <emu-clause id="sec-ordinary-object">
  176.       <h1>ordinary object</h1>
  177.       <p>object that has the default behaviour for the essential internal methods that must be supported by all objects</p>
  178.     </emu-clause>
  180.     <!-- es6num="4.3.7" -->
  181.     <emu-clause id="sec-exotic-object">
  182.       <h1>exotic object</h1>
  183.       <p>object that does not have the default behaviour for one or more of the essential internal methods</p>
  184.       <emu-note>
  185.         <p>Any object that is not an ordinary object is an exotic object.</p>
  186.       </emu-note>
  187.     </emu-clause>
  189.     <!-- es6num="4.3.8" -->
  190.     <emu-clause id="sec-standard-object">
  191.       <h1>standard object</h1>
  192.       <p>object whose semantics are defined by this specification</p>
  193.     </emu-clause>
  195.     <!-- es6num="4.3.9" -->
  196.     <emu-clause id="sec-built-in-object">
  197.       <h1>built-in object</h1>
  198.       <p>object specified and supplied by an ECMAScript implementation</p>
  199.       <emu-note>
  200.         <p>Standard built-in objects are defined in this specification. An ECMAScript implementation may specify and supply additional kinds of built-in objects. A <em>built-in constructor</em> is a built-in object that is also a constructor.</p>
  201.       </emu-note>
  202.     </emu-clause>
  204.     <!-- es6num="4.3.10" -->
  205.     <emu-clause id="sec-undefined-value">
  206.       <h1>undefined value</h1>
  207.       <p>primitive value used when a variable has not been assigned a value</p>
  208.     </emu-clause>
  210.     <!-- es6num="4.3.11" -->
  211.     <emu-clause id="sec-terms-and-definitions-undefined-type">
  212.       <h1>Undefined type</h1>
  213.       <p>type whose sole value is the *undefined* value</p>
  214.     </emu-clause>
  216.     <!-- es6num="4.3.12" -->
  217.     <emu-clause id="sec-null-value">
  218.       <h1>null value</h1>
  219.       <p>primitive value that represents the intentional absence of any object value</p>
  220.     </emu-clause>
  222.     <!-- es6num="4.3.13" -->
  223.     <emu-clause id="sec-terms-and-definitions-null-type">
  224.       <h1>Null type</h1>
  225.       <p>type whose sole value is the *null* value</p>
  226.     </emu-clause>
  228.     <!-- es6num="4.3.14" -->
  229.     <emu-clause id="sec-terms-and-definitions-boolean-value">
  230.       <h1>Boolean value</h1>
  231.       <p>member of the Boolean type</p>
  232.       <emu-note>
  233.         <p>There are only two Boolean values, *true* and *false*</p>
  234.       </emu-note>
  235.     </emu-clause>
  237.     <!-- es6num="4.3.15" -->
  238.     <emu-clause id="sec-terms-and-definitions-boolean-type">
  239.       <h1>Boolean type</h1>
  240.       <p>type consisting of the primitive values *true* and *false*</p>
  241.     </emu-clause>
  243.     <!-- es6num="4.3.16" -->
  244.     <emu-clause id="sec-boolean-object">
  245.       <h1>Boolean object</h1>
  246.       <p>member of the Object type that is an instance of the standard built-in `Boolean` constructor</p>
  247.       <emu-note>
  248.         <p>A Boolean object is created by using the `Boolean` constructor in a `new` expression, supplying a Boolean value as an argument. The resulting object has an internal slot whose value is the Boolean value. A Boolean object can be coerced to a Boolean value.</p>
  249.       </emu-note>
  250.     </emu-clause>
  252.     <!-- es6num="4.3.17" -->
  253.     <emu-clause id="sec-terms-and-definitions-string-value">
  254.       <h1>String value</h1>
  255.       <p>primitive value that is a finite ordered sequence of zero or more 16-bit unsigned integer</p>
  256.       <emu-note>
  257.         <p>A String value is a member of the String type. Each integer value in the sequence usually represents a single 16-bit unit of UTF-16 text. However, ECMAScript does not place any restrictions or requirements on the values except that they must be 16-bit unsigned integers.</p>
  258.       </emu-note>
  259.     </emu-clause>
  261.     <!-- es6num="4.3.18" -->
  262.     <emu-clause id="sec-terms-and-definitions-string-type">
  263.       <h1>String type</h1>
  264.       <p>set of all possible String values</p>
  265.     </emu-clause>
  267.     <!-- es6num="4.3.19" -->
  268.     <emu-clause id="sec-string-object">
  269.       <h1>String object</h1>
  270.       <p>member of the Object type that is an instance of the standard built-in `String` constructor</p>
  271.       <emu-note>
  272.         <p>A String object is created by using the `String` constructor in a `new` expression, supplying a String value as an argument. The resulting object has an internal slot whose value is the String value. A String object can be coerced to a String value by calling the `String` constructor as a function (<emu-xref href="#sec-string-constructor-string-value"></emu-xref>).</p>
  273.       </emu-note>
  274.     </emu-clause>
  276.     <!-- es6num="4.3.20" -->
  277.     <emu-clause id="sec-terms-and-definitions-number-value">
  278.       <h1>Number value</h1>
  279.       <p>primitive value corresponding to a double-precision 64-bit binary format IEEE 754-2008 value</p>
  280.       <emu-note>
  281.         <p>A Number value is a member of the Number type and is a direct representation of a number.</p>
  282.       </emu-note>
  283.     </emu-clause>
  285.     <!-- es6num="4.3.21" -->
  286.     <emu-clause id="sec-terms-and-definitions-number-type">
  287.       <h1>Number type</h1>
  288.       <p>set of all possible Number values including the special &ldquo;Not-a-Number&rdquo; (NaN) value, positive infinity, and negative infinity</p>
  289.     </emu-clause>
  291.     <!-- es6num="4.3.22" -->
  292.     <emu-clause id="sec-number-object">
  293.       <h1>Number object</h1>
  294.       <p>member of the Object type that is an instance of the standard built-in `Number` constructor</p>
  295.       <emu-note>
  296.         <p>A Number object is created by using the `Number` constructor in a `new` expression, supplying a number value as an argument. The resulting object has an internal slot whose value is the number value. A Number object can be coerced to a number value by calling the `Number` constructor as a function (<emu-xref href="#sec-number-constructor-number-value"></emu-xref>).</p>
  297.       </emu-note>
  298.     </emu-clause>
  300.     <!-- es6num="4.3.23" -->
  301.     <emu-clause id="sec-terms-and-definitions-infinity">
  302.       <h1>Infinity</h1>
  303.       <p>number value that is the positive infinite number value</p>
  304.     </emu-clause>
  306.     <!-- es6num="4.3.24" -->
  307.     <emu-clause id="sec-terms-and-definitions-nan">
  308.       <h1>NaN</h1>
  309.       <p>number value that is an IEEE 754-2008 &ldquo;Not-a-Number&rdquo; value</p>
  310.     </emu-clause>
  312.     <!-- es6num="4.3.25" -->
  313.     <emu-clause id="sec-symbol-value">
  314.       <h1>Symbol value</h1>
  315.       <p>primitive value that represents a unique, non-String Object property key</p>
  316.     </emu-clause>
  318.     <!-- es6num="4.3.26" -->
  319.     <emu-clause id="sec-terms-and-definitions-symbol-type">
  320.       <h1>Symbol type</h1>
  321.       <p>set of all possible Symbol values</p>
  322.     </emu-clause>
  324.     <!-- es6num="4.3.27" -->
  325.     <emu-clause id="sec-symbol-object">
  326.       <h1>Symbol object</h1>
  327.       <p>member of the Object type that is an instance of the standard built-in `Symbol` constructor</p>
  328.     </emu-clause>
  330.     <!-- es6num="4.3.28" -->
  331.     <emu-clause id="sec-terms-and-definitions-function">
  332.       <h1>function</h1>
  333.       <p>member of the Object type that may be invoked as a subroutine</p>
  334.       <emu-note>
  335.         <p>In addition to its properties, a function contains executable code and state that determine how it behaves when invoked. A function's code may or may not be written in ECMAScript.</p>
  336.       </emu-note>
  337.     </emu-clause>
  339.     <!-- es6num="4.3.29" -->
  340.     <emu-clause id="sec-built-in-function">
  341.       <h1>built-in function</h1>
  342.       <p>built-in object that is a function</p>
  343.       <emu-note>
  344.         <p>Examples of built-in functions include `parseInt` and `Math.exp`. An implementation may provide implementation-dependent built-in functions that are not described in this specification.</p>
  345.       </emu-note>
  346.     </emu-clause>
  348.     <!-- es6num="4.3.30" -->
  349.     <emu-clause id="sec-property">
  350.       <h1>property</h1>
  351.       <p>part of an object that associates a key (either a String value or a Symbol value) and a value</p>
  352.       <emu-note>
  353.         <p>Depending upon the form of the property the value may be represented either directly as a data value (a primitive value, an object, or a function object) or indirectly by a pair of accessor functions.</p>
  354.       </emu-note>
  355.     </emu-clause>
  357.     <!-- es6num="4.3.31" -->
  358.     <emu-clause id="sec-method">
  359.       <h1>method</h1>
  360.       <p>function that is the value of a property</p>
  361.       <emu-note>
  362.         <p>When a function is called as a method of an object, the object is passed to the function as its *this* value.</p>
  363.       </emu-note>
  364.     </emu-clause>
  366.     <!-- es6num="4.3.32" -->
  367.     <emu-clause id="sec-built-in-method">
  368.       <h1>built-in method</h1>
  369.       <p>method that is a built-in function</p>
  370.       <emu-note>
  371.         <p>Standard built-in methods are defined in this specification, and an ECMAScript implementation may specify and provide other additional built-in methods.</p>
  372.       </emu-note>
  373.     </emu-clause>
  375.     <!-- es6num="4.3.33" -->
  376.     <emu-clause id="sec-attribute">
  377.       <h1>attribute</h1>
  378.       <p>internal value that defines some characteristic of a property</p>
  379.     </emu-clause>
  381.     <!-- es6num="4.3.34" -->
  382.     <emu-clause id="sec-own-property">
  383.       <h1>own property</h1>
  384.       <p>property that is directly contained by its object</p>
  385.     </emu-clause>
  387.     <!-- es6num="4.3.35" -->
  388.     <emu-clause id="sec-inherited-property">
  389.       <h1>inherited property</h1>
  390.       <p>property of an object that is not an own property but is a property (either own or inherited) of the object's prototype</p>
  391.     </emu-clause>
  392.   </emu-clause>
  394.   <!-- es6num="4.4" -->
  395.   <emu-clause id="sec-organization-of-this-specification">
  396.     <h1>Organization of This Specification</h1>
  397.     <p>The remainder of this specification is organized as follows:</p>
  398.     <p>Clause 5 defines the notational conventions used throughout the specification.</p>
  399.     <p>Clauses 6-9 define the execution environment within which ECMAScript programs operate.</p>
  400.     <p>Clauses 10-16 define the actual ECMAScript programming language including its syntactic encoding and the execution semantics of all language features.</p>
  401.     <p>Clauses 17-26 define the ECMAScript standard library. It includes the definitions of all of the standard objects that are available for use by ECMAScript programs as they execute.</p>
  402.   </emu-clause>
  403. </emu-clause>
  405. <!-- es6num="5" -->
  406. <emu-clause id="sec-notational-conventions">
  407.   <h1>Notational Conventions</h1>
  409.   <!-- es6num="5.1" -->
  410.   <emu-clause id="sec-syntactic-and-lexical-grammars">
  411.     <h1>Syntactic and Lexical Grammars</h1>
  413.     <!-- es6num="5.1.1" -->
  414.     <emu-clause id="sec-context-free-grammars">
  415.       <h1>Context-Free Grammars</h1>
  416.       <p>A <em>context-free grammar</em> consists of a number of <em>productions</em>. Each production has an abstract symbol called a <em>nonterminal</em> as its <em>left-hand side</em>, and a sequence of zero or more nonterminal and <em>terminal</em> symbols as its <em>right-hand side</em>. For each grammar, the terminal symbols are drawn from a specified alphabet.</p>
  417.       <p>A <dfn>chain production</dfn> is a production that has exactly one nonterminal symbol on its right-hand side along with zero or more terminal symbols.</p>
  418.       <p>Starting from a sentence consisting of a single distinguished nonterminal, called the <dfn>goal symbol</dfn>, a given context-free grammar specifies a <em>language</em>, namely, the (perhaps infinite) set of possible sequences of terminal symbols that can result from repeatedly replacing any nonterminal in the sequence with a right-hand side of a production for which the nonterminal is the left-hand side.</p>
  419.     </emu-clause>
  421.     <!-- es6num="5.1.2" -->
  422.     <emu-clause id="sec-lexical-and-regexp-grammars">
  423.       <h1>The Lexical and RegExp Grammars</h1>
  424.       <p>A <em>lexical grammar</em> for ECMAScript is given in clause <emu-xref href="#sec-ecmascript-language-lexical-grammar"></emu-xref>. This grammar has as its terminal symbols Unicode code points that conform to the rules for |SourceCharacter| defined in <emu-xref href="#sec-source-text"></emu-xref>. It defines a set of productions, starting from the goal symbol |InputElementDiv|, |InputElementTemplateTail|, or |InputElementRegExp|, or |InputElementRegExpOrTemplateTail|, that describe how sequences of such code points are translated into a sequence of input elements.</p>
  425.       <p>Input elements other than white space and comments form the terminal symbols for the syntactic grammar for ECMAScript and are called ECMAScript <em>tokens</em>. These tokens are the reserved words, identifiers, literals, and punctuators of the ECMAScript language. Moreover, line terminators, although not considered to be tokens, also become part of the stream of input elements and guide the process of automatic semicolon insertion (<emu-xref href="#sec-automatic-semicolon-insertion"></emu-xref>). Simple white space and single-line comments are discarded and do not appear in the stream of input elements for the syntactic grammar. A |MultiLineComment| (that is, a comment of the form `/*`&hellip;`*/` regardless of whether it spans more than one line) is likewise simply discarded if it contains no line terminator; but if a |MultiLineComment| contains one or more line terminators, then it is replaced by a single line terminator, which becomes part of the stream of input elements for the syntactic grammar.</p>
  426.       <p>A <em>RegExp grammar</em> for ECMAScript is given in <emu-xref href="#sec-patterns"></emu-xref>. This grammar also has as its terminal symbols the code points as defined by |SourceCharacter|. It defines a set of productions, starting from the goal symbol |Pattern|, that describe how sequences of code points are translated into regular expression patterns.</p>
  427.       <p>Productions of the lexical and RegExp grammars are distinguished by having two colons &ldquo;<b>::</b>&rdquo; as separating punctuation. The lexical and RegExp grammars share some productions.</p>
  428.     </emu-clause>
  430.     <!-- es6num="5.1.3" -->
  431.     <emu-clause id="sec-numeric-string-grammar">
  432.       <h1>The Numeric String Grammar</h1>
  433.       <p>Another grammar is used for translating Strings into numeric values. This grammar is similar to the part of the lexical grammar having to do with numeric literals and has as its terminal symbols |SourceCharacter|. This grammar appears in <emu-xref href="#sec-tonumber-applied-to-the-string-type"></emu-xref>.</p>
  434.       <p>Productions of the numeric string grammar are distinguished by having three colons &ldquo;<b>:::</b>&rdquo; as punctuation.</p>
  435.     </emu-clause>
  437.     <!-- es6num="5.1.4" -->
  438.     <emu-clause id="sec-syntactic-grammar">
  439.       <h1>The Syntactic Grammar</h1>
  440.       <p>The <em>syntactic grammar</em> for ECMAScript is given in clauses 11, 12, 13, 14, and 15. This grammar has ECMAScript tokens defined by the lexical grammar as its terminal symbols (<emu-xref href="#sec-lexical-and-regexp-grammars"></emu-xref>). It defines a set of productions, starting from two alternative goal symbols |Script| and |Module|, that describe how sequences of tokens form syntactically correct independent components of ECMAScript programs.</p>
  441.       <p>When a stream of code points is to be parsed as an ECMAScript |Script| or |Module|, it is first converted to a stream of input elements by repeated application of the lexical grammar; this stream of input elements is then parsed by a single application of the syntactic grammar. The input stream is syntactically in error if the tokens in the stream of input elements cannot be parsed as a single instance of the goal nonterminal (|Script| or |Module|), with no tokens left over.</p>
  442.       <p>Productions of the syntactic grammar are distinguished by having just one colon &ldquo;<b>:</b>&rdquo; as punctuation.</p>
  443.       <p>The syntactic grammar as presented in clauses 12, 13, 14 and 15 is not a complete account of which token sequences are accepted as a correct ECMAScript |Script| or |Module|. Certain additional token sequences are also accepted, namely, those that would be described by the grammar if only semicolons were added to the sequence in certain places (such as before line terminator characters). Furthermore, certain token sequences that are described by the grammar are not considered acceptable if a line terminator character appears in certain &ldquo;awkward&rdquo; places.</p>
  444.       <p>In certain cases in order to avoid ambiguities the syntactic grammar uses generalized productions that permit token sequences that do not form a valid ECMAScript |Script| or |Module|. For example, this technique is used for object literals and object destructuring patterns. In such cases a more restrictive <em>supplemental grammar</em> is provided that further restricts the acceptable token sequences. In certain contexts, when explicitly specified, the input elements corresponding to such a production are parsed again using a goal symbol of a supplemental grammar. The input stream is syntactically in error if the tokens in the stream of input elements parsed by a cover grammar cannot be parsed as a single instance of the corresponding supplemental goal symbol, with no tokens left over.</p>
  445.     </emu-clause>
  447.     <!-- es6num="5.1.5" -->
  448.     <emu-clause id="sec-grammar-notation" namespace=grammar-notation>
  449.       <h1>Grammar Notation</h1>
  450.       <p>Terminal symbols of the lexical, RegExp, and numeric string grammars are shown in `fixed width` font, both in the productions of the grammars and throughout this specification whenever the text directly refers to such a terminal symbol. These are to appear in a script exactly as written. All terminal symbol code points specified in this way are to be understood as the appropriate Unicode code points from the Basic Latin range, as opposed to any similar-looking code points from other Unicode ranges.</p>
  451.       <p>Nonterminal symbols are shown in _italic_ type. The definition of a nonterminal (also called a &ldquo;production&rdquo;) is introduced by the name of the nonterminal being defined followed by one or more colons. (The number of colons indicates to which grammar the production belongs.) One or more alternative right-hand sides for the nonterminal then follow on succeeding lines. For example, the syntactic definition:</p>
  452.       <emu-grammar>
  453.         WhileStatement :
  454.           `while` `(` Expression `)` Statement
  455.       </emu-grammar>
  456.       <p>states that the nonterminal |WhileStatement| represents the token `while`, followed by a left parenthesis token, followed by an |Expression|, followed by a right parenthesis token, followed by a |Statement|. The occurrences of |Expression| and |Statement| are themselves nonterminals. As another example, the syntactic definition:</p>
  457.       <emu-grammar>
  458.         ArgumentList :
  459.           AssignmentExpression
  460.           ArgumentList `,` AssignmentExpression
  461.       </emu-grammar>
  462.       <p>states that an |ArgumentList| may represent either a single |AssignmentExpression| or an |ArgumentList|, followed by a comma, followed by an |AssignmentExpression|. This definition of |ArgumentList| is recursive, that is, it is defined in terms of itself. The result is that an |ArgumentList| may contain any positive number of arguments, separated by commas, where each argument expression is an |AssignmentExpression|. Such recursive definitions of nonterminals are common.</p>
  463.       <p>The subscripted suffix &ldquo;<sub>opt</sub>&rdquo;, which may appear after a terminal or nonterminal, indicates an optional symbol. The alternative containing the optional symbol actually specifies two right-hand sides, one that omits the optional element and one that includes it. This means that:</p>
  464.       <emu-grammar>
  465.         VariableDeclaration :
  466.           BindingIdentifier Initializer?
  467.       </emu-grammar>
  468.       <p>is a convenient abbreviation for:</p>
  469.       <emu-grammar>
  470.         VariableDeclaration :
  471.           BindingIdentifier
  472.           BindingIdentifier Initializer
  473.       </emu-grammar>
  474.       <p>and that:</p>
  475.       <emu-grammar>
  476.         IterationStatement :
  477.           `for` `(` LexicalDeclaration Expression? `;` Expression? `)` Statement
  478.       </emu-grammar>
  479.       <p>is a convenient abbreviation for:</p>
  480.       <emu-grammar>
  481.         IterationStatement :
  482.           `for` `(` LexicalDeclaration `;` Expression? `)` Statement
  483.           `for` `(` LexicalDeclaration Expression `;` Expression? `)` Statement
  484.       </emu-grammar>
  485.       <p>which in turn is an abbreviation for:</p>
  486.       <emu-grammar>
  487.         IterationStatement :
  488.           `for` `(` LexicalDeclaration `;` `)` Statement
  489.           `for` `(` LexicalDeclaration `;` Expression `)` Statement
  490.           `for` `(` LexicalDeclaration Expression `;` `)` Statement
  491.           `for` `(` LexicalDeclaration Expression `;` Expression `)` Statement
  492.       </emu-grammar>
  493.       <p>so, in this example, the nonterminal |IterationStatement| actually has four alternative right-hand sides.</p>
  494.       <p>A production may be parameterized by a subscripted annotation of the form &ldquo;<sub>[parameters]</sub>&rdquo;, which may appear as a suffix to the nonterminal symbol defined by the production. &ldquo;<sub>parameters</sub>&rdquo; may be either a single name or a comma separated list of names. A parameterized production is shorthand for a set of productions defining all combinations of the parameter names, preceded by an underscore, appended to the parameterized nonterminal symbol. This means that:</p>
  495.       <emu-grammar>
  496.         StatementList[Return] :
  497.           ReturnStatement
  498.           ExpressionStatement
  499.       </emu-grammar>
  500.       <p>is a convenient abbreviation for:</p>
  501.       <emu-grammar>
  502.         StatementList :
  503.           ReturnStatement
  504.           ExpressionStatement
  506.         StatementList_Return :
  507.           ReturnStatement
  508.           ExpressionStatement
  509.       </emu-grammar>
  510.       <p>and that:</p>
  511.       <emu-grammar>
  512.         StatementList[Return, In] :
  513.           ReturnStatement
  514.           ExpressionStatement
  515.       </emu-grammar>
  516.       <p>is an abbreviation for:</p>
  517.       <emu-grammar>
  518.         StatementList :
  519.           ReturnStatement
  520.           ExpressionStatement
  522.         StatementList_Return :
  523.           ReturnStatement
  524.           ExpressionStatement
  526.         StatementList_In :
  527.           ReturnStatement
  528.           ExpressionStatement
  530.         StatementList_Return_In :
  531.           ReturnStatement
  532.           ExpressionStatement
  533.       </emu-grammar>
  534.       <p>Multiple parameters produce a combinatory number of productions, not all of which are necessarily referenced in a complete grammar.</p>
  535.       <p>References to nonterminals on the right-hand side of a production can also be parameterized. For example:</p>
  536.       <emu-grammar>
  537.         StatementList :
  538.           ReturnStatement
  539.           ExpressionStatement[+In]
  540.       </emu-grammar>
  541.       <p>is equivalent to saying:</p>
  542.       <emu-grammar>
  543.         StatementList :
  544.           ReturnStatement
  545.           ExpressionStatement_In
  546.       </emu-grammar>
  547.       <p>and</p>
  548.       <emu-grammar>
  549.         StatementList :
  550.           ReturnStatement
  551.           ExpressionStatement[~In]
  552.       </emu-grammar>
  553.       <p>is equivalent to:</p>
  554.       <emu-grammar>
  555.         StatementList :
  556.           ReturnStatement
  557.           ExpressionStatement
  558.       </emu-grammar>
  559.       <p>A nonterminal reference may have both a parameter list and an &ldquo;<sub>opt</sub>&rdquo; suffix. For example:</p>
  560.       <emu-grammar>
  561.         VariableDeclaration :
  562.           BindingIdentifier Initializer[+In]?
  563.       </emu-grammar>
  564.       <p>is an abbreviation for:</p>
  565.       <emu-grammar>
  566.         VariableDeclaration :
  567.           BindingIdentifier
  568.           BindingIdentifier Initializer_In
  569.       </emu-grammar>
  570.       <p>Prefixing a parameter name with &ldquo;<sub>?</sub>&rdquo; on a right-hand side nonterminal reference makes that parameter value dependent upon the occurrence of the parameter name on the reference to the current production's left-hand side symbol. For example:</p>
  571.       <emu-grammar>
  572.         VariableDeclaration[In] :
  573.           BindingIdentifier Initializer[?In]
  574.       </emu-grammar>
  575.       <p>is an abbreviation for:</p>
  576.       <emu-grammar>
  577.         VariableDeclaration :
  578.           BindingIdentifier Initializer
  580.         VariableDeclaration_In :
  581.           BindingIdentifier Initializer_In
  582.       </emu-grammar>
  583.       <p>If a right-hand side alternative is prefixed with &ldquo;[+parameter]&rdquo; that alternative is only available if the named parameter was used in referencing the production's nonterminal symbol. If a right-hand side alternative is prefixed with &ldquo;[\~parameter]&rdquo; that alternative is only available if the named parameter was <em>not</em> used in referencing the production's nonterminal symbol. This means that:</p>
  584.       <emu-grammar>
  585.         StatementList[Return] :
  586.           [+Return] ReturnStatement
  587.           ExpressionStatement
  588.       </emu-grammar>
  589.       <p>is an abbreviation for:</p>
  590.       <emu-grammar>
  591.         StatementList :
  592.           ExpressionStatement
  594.         StatementList_Return :
  595.           ReturnStatement
  596.           ExpressionStatement
  597.       </emu-grammar>
  598.       <p>and that</p>
  599.       <emu-grammar>
  600.         StatementList[Return] :
  601.           [~Return] ReturnStatement
  602.           ExpressionStatement
  603.       </emu-grammar>
  604.       <p>is an abbreviation for:</p>
  605.       <emu-grammar>
  606.         StatementList :
  607.           ReturnStatement
  608.           ExpressionStatement
  610.         StatementList_Return :
  611.           ExpressionStatement
  612.       </emu-grammar>
  613.       <p>When the words &ldquo;<b>one of</b>&rdquo; follow the colon(s) in a grammar definition, they signify that each of the terminal symbols on the following line or lines is an alternative definition. For example, the lexical grammar for ECMAScript contains the production:</p>
  614.       <emu-grammar>
  615.         NonZeroDigit :: one of
  616.           `1` `2` `3` `4` `5` `6` `7` `8` `9`
  617.       </emu-grammar>
  618.       <p>which is merely a convenient abbreviation for:</p>
  619.       <emu-grammar>
  620.         NonZeroDigit ::
  621.           `1`
  622.           `2`
  623.           `3`
  624.           `4`
  625.           `5`
  626.           `6`
  627.           `7`
  628.           `8`
  629.           `9`
  630.       </emu-grammar>
  631.       <p>If the phrase &ldquo;[empty]&rdquo; appears as the right-hand side of a production, it indicates that the production's right-hand side contains no terminals or nonterminals.</p>
  632.       <p>If the phrase &ldquo;[lookahead &notin; _set_]&rdquo; appears in the right-hand side of a production, it indicates that the production may not be used if the immediately following input token sequence is a member of the given _set_. The _set_ can be written as a comma separated list of one or two element terminal sequences enclosed in curly brackets. For convenience, the set can also be written as a nonterminal, in which case it represents the set of all terminals to which that nonterminal could expand. If the _set_ consists of a single terminal the phrase &ldquo;[lookahead &ne; _terminal_]&rdquo; may be used.</p>
  633.       <p>For example, given the definitions</p>
  634.       <emu-grammar>
  635.         DecimalDigit :: one of
  636.           `0` `1` `2` `3` `4` `5` `6` `7` `8` `9`
  638.         DecimalDigits ::
  639.           DecimalDigit
  640.           DecimalDigits DecimalDigit
  641.       </emu-grammar>
  642.       <p>the definition</p>
  643.       <emu-grammar>
  644.         LookaheadExample ::
  645.           `n` [lookahead &lt;! {`1`, `3`, `5`, `7`, `9`}] DecimalDigits
  646.           DecimalDigit [lookahead &lt;! DecimalDigit]
  647.       </emu-grammar>
  648.       <p>matches either the letter `n` followed by one or more decimal digits the first of which is even, or a decimal digit not followed by another decimal digit.</p>
  649.       <p>If the phrase &ldquo;[no |LineTerminator| here]&rdquo; appears in the right-hand side of a production of the syntactic grammar, it indicates that the production is <em>a restricted production</em>: it may not be used if a |LineTerminator| occurs in the input stream at the indicated position. For example, the production:</p>
  650.       <emu-grammar>
  651.         ThrowStatement :
  652.           `throw` [no LineTerminator here] Expression `;`
  653.       </emu-grammar>
  654.       <p>indicates that the production may not be used if a |LineTerminator| occurs in the script between the `throw` token and the |Expression|.</p>
  655.       <p>Unless the presence of a |LineTerminator| is forbidden by a restricted production, any number of occurrences of |LineTerminator| may appear between any two consecutive tokens in the stream of input elements without affecting the syntactic acceptability of the script.</p>
  656.       <p>When an alternative in a production of the lexical grammar or the numeric string grammar appears to be a multi-code point token, it represents the sequence of code points that would make up such a token.</p>
  657.       <p>The right-hand side of a production may specify that certain expansions are not permitted by using the phrase &ldquo;<b>but not</b>&rdquo; and then indicating the expansions to be excluded. For example, the production:</p>
  658.       <emu-grammar>
  659.         Identifier ::
  660.           IdentifierName but not ReservedWord
  661.       </emu-grammar>
  662.       <p>means that the nonterminal |Identifier| may be replaced by any sequence of code points that could replace |IdentifierName| provided that the same sequence of code points could not replace |ReservedWord|.</p>
  663.       <p>Finally, a few nonterminal symbols are described by a descriptive phrase in sans-serif type in cases where it would be impractical to list all the alternatives:</p>
  664.       <emu-grammar>
  665.         SourceCharacter ::
  666.           &gt; any Unicode code point
  667.       </emu-grammar>
  668.     </emu-clause>
  669.   </emu-clause>
  671.   <!-- es6num="5.2" -->
  672.   <emu-clause id="sec-algorithm-conventions" namespace=algorithm-conventions>
  673.     <h1>Algorithm Conventions</h1>
  674.     <p>The specification often uses a numbered list to specify steps in an algorithm. These algorithms are used to precisely specify the required semantics of ECMAScript language constructs. The algorithms are not intended to imply the use of any specific implementation technique. In practice, there may be more efficient algorithms available to implement a given feature.</p>
  675.     <p>Algorithms may be explicitly parameterized, in which case the names and usage of the parameters must be provided as part of the algorithm's definition. In order to facilitate their use in multiple parts of this specification, some algorithms, called <em>abstract operations</em>, are named and written in parameterized functional form so that they may be referenced by name from within other algorithms. Abstract operations are typically referenced using a functional application style such as operationName(_arg1_, _arg2_). Some abstract operations are treated as polymorphically dispatched methods of class-like specification abstractions. Such method-like abstract operations are typically referenced using a method application style such as _someValue_.operationName(_arg1_, _arg2_).</p>
  676.     <p>Calls to abstract operations return Completion Records. Abstract operations referenced using the functional application style and the method application style that are prefixed by `?` indicate that ReturnIfAbrupt should be applied to the resulting Completion Record. For example, ? operationName() is equivalent to ReturnIfAbrupt(operationName()). Similarly, ? _someValue_.operationName() is equivalent to ReturnIfAbrupt(_someValue_.operationName()).</p>
  677.     <p>The prefix `!` is used to indicate that an abstract operation will never return an abrupt completion and that the resulting Completion Record's value field should be used in place of the return value of the operation. For example, &ldquo;Let _val_ be ! operationName()&rdquo; is equivalent to the following algorithm steps:</p>
  678.     <emu-alg>
  679.       1. Let _val_ be operationName().
  680.       1. Assert: _val_ is never an abrupt completion.
  681.       1. If _val_ is a Completion Record, let _val_ be _val_.[[Value]].
  682.     </emu-alg>
  683.     <p>Algorithms may be associated with productions of one of the ECMAScript grammars. A production that has multiple alternative definitions will typically have a distinct algorithm for each alternative. When an algorithm is associated with a grammar production, it may reference the terminal and nonterminal symbols of the production alternative as if they were parameters of the algorithm. When used in this manner, nonterminal symbols refer to the actual alternative definition that is matched when parsing the source text.</p>
  684.     <p>When an algorithm is associated with a production alternative, the alternative is typically shown without any &ldquo;[ ]&rdquo; grammar annotations. Such annotations should only affect the syntactic recognition of the alternative and have no effect on the associated semantics for the alternative.</p>
  685.     <p>Unless explicitly specified otherwise, all chain productions have an implicit definition for every algorithm that might be applied to that production's left-hand side nonterminal. The implicit definition simply reapplies the same algorithm name with the same parameters, if any, to the chain production's sole right-hand side nonterminal and then returns the result. For example, assume there is a production:</p>
  686.     <emu-grammar>
  687.       Block :
  688.         `{` StatementList `}`
  689.     </emu-grammar>
  690.     <p>but there is no corresponding Evaluation algorithm that is explicitly specified for that production. If in some algorithm there is a statement of the form: &ldquo;Return the result of evaluating |Block|&rdquo; it is implicit that an Evaluation algorithm exists of the form:</p>
  691.     <p><b>Runtime Semantics: Evaluation</b></p>
  692.     <emu-grammar>Block : `{` StatementList `}`</emu-grammar>
  693.     <emu-alg>
  694.       1. Return the result of evaluating |StatementList|.
  695.     </emu-alg>
  696.     <p>For clarity of expression, algorithm steps may be subdivided into sequential substeps. Substeps are indented and may themselves be further divided into indented substeps. Outline numbering conventions are used to identify substeps with the first level of substeps labelled with lower case alphabetic characters and the second level of substeps labelled with lower case roman numerals. If more than three levels are required these rules repeat with the fourth level using numeric labels. For example:</p>
  697.     <emu-alg>
  698.       1. Top-level step
  699.         1. Substep.
  700.         1. Substep.
  701.           1. Subsubstep.
  702.             1. Subsubsubstep
  703.               1. Subsubsubsubstep
  704.                 1. Subsubsubsubsubstep
  705.     </emu-alg>
  706.     <p>A step or substep may be written as an &ldquo;if&rdquo; predicate that conditions its substeps. In this case, the substeps are only applied if the predicate is true. If a step or substep begins with the word &ldquo;else&rdquo;, it is a predicate that is the negation of the preceding &ldquo;if&rdquo; predicate step at the same level.</p>
  707.     <p>A step may specify the iterative application of its substeps.</p>
  708.     <p>A step that begins with &ldquo;<dfn id="assert">Assert</dfn>:&rdquo; asserts an invariant condition of its algorithm. Such assertions are used to make explicit algorithmic invariants that would otherwise be implicit. Such assertions add no additional semantic requirements and hence need not be checked by an implementation. They are used simply to clarify algorithms.</p>
  709.     <p>Algorithm steps may declare named aliases for any value using the form &ldquo;Let _x_ be _someValue_&rdquo;. These aliases are reference-like in that both _x_ and _someValue_ refer to the same underlying data and modifications to either are visible to both. Algorithm steps that want to avoid this reference-like behavior should explicitly make a copy of the right-hand side: &ldquo;Let _x_ be a copy of _someValue_&rdquo; creates a shallow copy of _someValue_.</p>
  710.     <p>Mathematical operations such as addition, subtraction, negation, multiplication, division, and the mathematical functions defined later in this clause should always be understood as computing exact mathematical results on mathematical real numbers, which unless otherwise noted do not include infinities and do not include a negative zero that is distinguished from positive zero. Algorithms in this standard that model floating-point arithmetic include explicit steps, where necessary, to handle infinities and signed zero and to perform rounding. If a mathematical operation or function is applied to a floating-point number, it should be understood as being applied to the exact mathematical value represented by that floating-point number; such a floating-point number must be finite, and if it is *+0* or *-0* then the corresponding mathematical value is simply 0.</p>
  711.     <p>The mathematical function <emu-eqn id="eqn-abs" aoid="abs">abs(_x_)</emu-eqn> produces the absolute value of _x_, which is <emu-eqn>-_x_</emu-eqn> if _x_ is negative (less than zero) and otherwise is _x_ itself.</p>
  712.     <p>The mathematical function <emu-eqn id="eqn-min" aoid="min">min(_x1_, _x2_, ..., _xN_)</emu-eqn> produces the mathematically smallest of <emu-eqn>_x1_</emu-eqn> through <emu-eqn>_xN_</emu-eqn>. The mathematical function <emu-eqn id="eqn-max" aoid="max">max(_x1_, _x2_, ..., _xN_)</emu-eqn> produces the mathematically largest of <emu-eqn>_x1_</emu-eqn> through <emu-eqn>_xN_</emu-eqn>. The domain and range of these mathematical functions include *+&infin;* and *-&infin;*.</p>
  713.     <p>The notation &ldquo;<emu-eqn id="eqn-modulo" aoid="modulo">_x_ modulo _y_</emu-eqn>&rdquo; (_y_ must be finite and nonzero) computes a value _k_ of the same sign as _y_ (or zero) such that <emu-eqn>abs(_k_) &lt; abs(_y_) and _x_-_k_ = _q_ &times; _y_</emu-eqn> for some integer _q_.</p>
  714.     <p>The mathematical function <emu-eqn id="eqn-floor" aoid="floor">floor(_x_)</emu-eqn> produces the largest integer (closest to positive infinity) that is not larger than _x_.</p>
  715.     <emu-note>
  716.       <p><emu-eqn>floor(_x_) = _x_-(_x_ modulo 1)</emu-eqn>.</p>
  717.     </emu-note>
  718.   </emu-clause>
  720.   <!-- es6num="5.3" -->
  721.   <emu-clause id="sec-static-semantic-rules">
  722.     <h1>Static Semantic Rules</h1>
  723.     <p>Context-free grammars are not sufficiently powerful to express all the rules that define whether a stream of input elements form a valid ECMAScript |Script| or |Module| that may be evaluated. In some situations additional rules are needed that may be expressed using either ECMAScript algorithm conventions or prose requirements. Such rules are always associated with a production of a grammar and are called the <em>static semantics</em> of the production.</p>
  724.     <p>Static Semantic Rules have names and typically are defined using an algorithm. Named Static Semantic Rules are associated with grammar productions and a production that has multiple alternative definitions will typically have for each alternative a distinct algorithm for each applicable named static semantic rule.</p>
  725.     <p>Unless otherwise specified every grammar production alternative in this specification implicitly has a definition for a static semantic rule named Contains which takes an argument named _symbol_ whose value is a terminal or nonterminal of the grammar that includes the associated production. The default definition of Contains is:</p>
  726.     <emu-alg>
  727.       1. For each terminal and nonterminal grammar symbol, _sym_, in the definition of this production do
  728.         1. If _sym_ is the same grammar symbol as _symbol_, return *true*.
  729.         1. If _sym_ is a nonterminal, then
  730.           1. Let _contained_ be the result of _sym_ Contains _symbol_.
  731.           1. If _contained_ is *true*, return *true*.
  732.       1. Return *false*.
  733.     </emu-alg>
  734.     <p>The above definition is explicitly over-ridden for specific productions.</p>
  735.     <p>A special kind of static semantic rule is an <dfn id="early-error-rule">Early Error Rule</dfn>. Early error rules define early error conditions (see clause <emu-xref href="#sec-error-handling-and-language-extensions"></emu-xref>) that are associated with specific grammar productions. Evaluation of most early error rules are not explicitly invoked within the algorithms of this specification. A conforming implementation must, prior to the first evaluation of a |Script| or |Module|, validate all of the early error rules of the productions used to parse that |Script| or |Module|. If any of the early error rules are violated the |Script| or |Module| is invalid and cannot be evaluated.</p>
  736.   </emu-clause>
  737. </emu-clause>
  739. <!-- es6num="6" -->
  740. <emu-clause id="sec-ecmascript-data-types-and-values" aoid="Type">
  741.   <h1>ECMAScript Data Types and Values</h1>
  742.   <p>Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further subclassified into ECMAScript language types and specification types.</p>
  743.   <p>Within this specification, the notation &ldquo;Type(_x_)&rdquo; is used as shorthand for &ldquo;the <dfn id="type">type</dfn> of _x_&rdquo; where &ldquo;type&rdquo; refers to the ECMAScript language and specification types defined in this clause. When the term &ldquo;empty&rdquo; is used as if it was naming a value, it is equivalent to saying &ldquo;no value of any type&rdquo;.</p>
  745.   <!-- es6num="6.1" -->
  746.   <emu-clause id="sec-ecmascript-language-types">
  747.     <h1>ECMAScript Language Types</h1>
  748.     <p>An <dfn>ECMAScript language type</dfn> corresponds to values that are directly manipulated by an ECMAScript programmer using the ECMAScript language. The ECMAScript language types are Undefined, Null, Boolean, String, Symbol, Number, and Object. An <dfn>ECMAScript language value</dfn> is a value that is characterized by an ECMAScript language type.</p>
  750.     <!-- es6num="6.1.1" -->
  751.     <emu-clause id="sec-ecmascript-language-types-undefined-type">
  752.       <h1>The Undefined Type</h1>
  753.       <p>The Undefined type has exactly one value, called *undefined*. Any variable that has not been assigned a value has the value *undefined*.</p>
  754.     </emu-clause>
  756.     <!-- es6num="6.1.2" -->
  757.     <emu-clause id="sec-ecmascript-language-types-null-type">
  758.       <h1>The Null Type</h1>
  759.       <p>The Null type has exactly one value, called *null*.</p>
  760.     </emu-clause>
  762.     <!-- es6num="6.1.3" -->
  763.     <emu-clause id="sec-ecmascript-language-types-boolean-type">
  764.       <h1>The Boolean Type</h1>
  765.       <p>The Boolean type represents a logical entity having two values, called *true* and *false*.</p>
  766.     </emu-clause>
  768.     <!-- es6num="6.1.4" -->
  769.     <emu-clause id="sec-ecmascript-language-types-string-type">
  770.       <h1>The String Type</h1>
  771.       <p>The String type is the set of all ordered sequences of zero or more 16-bit unsigned integer values (&ldquo;elements&rdquo;) up to a maximum length of 2<sup>53</sup>-1 elements. The String type is generally used to represent textual data in a running ECMAScript program, in which case each element in the String is treated as a UTF-16 code unit value. Each element is regarded as occupying a position within the sequence. These positions are indexed with nonnegative integers. The first element (if any) is at index 0, the next element (if any) at index 1, and so on. The length of a String is the number of elements (i.e., 16-bit values) within it. The empty String has length zero and therefore contains no elements.</p>
  772.       <p>Where ECMAScript operations interpret String values, each element is interpreted as a single UTF-16 code unit. However, ECMAScript does not place any restrictions or requirements on the sequence of code units in a String value, so they may be ill-formed when interpreted as UTF-16 code unit sequences. Operations that do not interpret String contents treat them as sequences of undifferentiated 16-bit unsigned integers. The function `String.prototype.normalize` (see <emu-xref href="#sec-string.prototype.normalize"></emu-xref>) can be used to explicitly normalize a String value. `String.prototype.localeCompare` (see <emu-xref href="#sec-string.prototype.localecompare"></emu-xref>) internally normalizes String values, but no other operations implicitly normalize the strings upon which they operate. Only operations that are explicitly specified to be language or locale sensitive produce language-sensitive results.</p>
  773.       <emu-note>
  774.         <p>The rationale behind this design was to keep the implementation of Strings as simple and high-performing as possible. If ECMAScript source text is in Normalized Form C, string literals are guaranteed to also be normalized, as long as they do not contain any Unicode escape sequences.</p>
  775.       </emu-note>
  776.       <p>Some operations interpret String contents as UTF-16 encoded Unicode code points. In that case the interpretation is:</p>
  777.       <ul>
  778.         <li>
  779.           A code unit in the range 0 to 0xD7FF or in the range 0xE000 to 0xFFFF is interpreted as a code point with the same value.
  780.         </li>
  781.         <li>
  782.           A sequence of two code units, where the first code unit _c1_ is in the range 0xD800 to 0xDBFF and the second code unit _c2_ is in the range 0xDC00 to 0xDFFF, is a surrogate pair and is interpreted as a code point with the value (_c1_ - 0xD800) &times; 0x400 + (_c2_ - 0xDC00) + 0x10000. (See <emu-xref href="#sec-utf16decode"></emu-xref>)
  783.         </li>
  784.         <li>
  785.           A code unit that is in the range 0xD800 to 0xDFFF, but is not part of a surrogate pair, is interpreted as a code point with the same value.
  786.         </li>
  787.       </ul>
  788.     </emu-clause>
  790.     <!-- es6num="6.1.5" -->
  791.     <emu-clause id="sec-ecmascript-language-types-symbol-type">
  792.       <h1>The Symbol Type</h1>
  793.       <p>The Symbol type is the set of all non-String values that may be used as the key of an Object property (<emu-xref href="#sec-object-type"></emu-xref>).</p>
  794.       <p>Each possible Symbol value is unique and immutable.</p>
  795.       <p>Each Symbol value immutably holds an associated value called [[Description]] that is either *undefined* or a String value.</p>
  797.       <!-- es6num="" -->
  798.       <emu-clause id="sec-well-known-symbols">
  799.         <h1>Well-Known Symbols</h1>
  800.         <p>Well-known symbols are built-in Symbol values that are explicitly referenced by algorithms of this specification. They are typically used as the keys of properties whose values serve as extension points of a specification algorithm. Unless otherwise specified, well-known symbols values are shared by all realms (<emu-xref href="#sec-code-realms"></emu-xref>).</p>
  801.         <p>Within this specification a well-known symbol is referred to by using a notation of the form @@name, where &ldquo;name&rdquo; is one of the values listed in <emu-xref href="#table-1"></emu-xref>.</p>
  802.         <emu-table id="table-1" caption="Well-known Symbols">
  803.           <table>
  804.             <tbody>
  805.             <tr>
  806.               <th>
  807.                 Specification Name
  808.               </th>
  809.               <th>
  810.                 [[Description]]
  811.               </th>
  812.               <th>
  813.                 Value and Purpose
  814.               </th>
  815.             </tr>
  816.             <tr>
  817.               <td>
  818.                 @@hasInstance
  819.               </td>
  820.               <td>
  821.                 `"Symbol.hasInstance"`
  822.               </td>
  823.               <td>
  824.                 A method that determines if a constructor object recognizes an object as one of the constructor's instances. Called by the semantics of the `instanceof` operator.
  825.               </td>
  826.             </tr>
  827.             <tr>
  828.               <td>
  829.                 @@isConcatSpreadable
  830.               </td>
  831.               <td>
  832.                 `"Symbol.isConcatSpreadable"`
  833.               </td>
  834.               <td>
  835.                 A Boolean valued property that if true indicates that an object should be flattened to its array elements by <emu-xref href="#sec-array.prototype.concat">`Array.prototype.concat`</emu-xref>.
  836.               </td>
  837.             </tr>
  838.             <tr>
  839.               <td>
  840.                 @@iterator
  841.               </td>
  842.               <td>
  843.                 `"Symbol.iterator"`
  844.               </td>
  845.               <td>
  846.                 A method that returns the default Iterator for an object. Called by the semantics of the for-of statement.
  847.               </td>
  848.             </tr>
  849.             <tr>
  850.               <td>
  851.                 @@match
  852.               </td>
  853.               <td>
  854.                 `"Symbol.match"`
  855.               </td>
  856.               <td>
  857.                 A regular expression method that matches the regular expression against a string. Called by the <emu-xref href="#sec-string.prototype.match">`String.prototype.match`</emu-xref> method.
  858.               </td>
  859.             </tr>
  860.             <tr>
  861.               <td>
  862.                 @@replace
  863.               </td>
  864.               <td>
  865.                 `"Symbol.replace"`
  866.               </td>
  867.               <td>
  868.                 A regular expression method that replaces matched substrings of a string. Called by the <emu-xref href="#sec-string.prototype.replace">`String.prototype.replace`</emu-xref> method.
  869.               </td>
  870.             </tr>
  871.             <tr>
  872.               <td>
  873.                 @@search
  874.               </td>
  875.               <td>
  876.                 `""`
  877.               </td>
  878.               <td>
  879.                 A regular expression method that returns the index within a string that matches the regular expression. Called by the <emu-xref href="">``</emu-xref> method.
  880.               </td>
  881.             </tr>
  882.             <tr>
  883.               <td>
  884.                 @@species
  885.               </td>
  886.               <td>
  887.                 `"Symbol.species"`
  888.               </td>
  889.               <td>
  890.                 A function valued property that is the constructor function that is used to create derived objects.
  891.               </td>
  892.             </tr>
  893.             <tr>
  894.               <td>
  895.                 @@split
  896.               </td>
  897.               <td>
  898.                 `"Symbol.split"`
  899.               </td>
  900.               <td>
  901.                 A regular expression method that splits a string at the indices that match the regular expression. Called by the <emu-xref href="#sec-string.prototype.split">`String.prototype.split`</emu-xref> method.
  902.               </td>
  903.             </tr>
  904.             <tr>
  905.               <td>
  906.                 @@toPrimitive
  907.               </td>
  908.               <td>
  909.                 `"Symbol.toPrimitive"`
  910.               </td>
  911.               <td>
  912.                 A method that converts an object to a corresponding primitive value. Called by the ToPrimitive abstract operation.
  913.               </td>
  914.             </tr>
  915.             <tr>
  916.               <td>
  917.                 @@toStringTag
  918.               </td>
  919.               <td>
  920.                 `"Symbol.toStringTag"`
  921.               </td>
  922.               <td>
  923.                 A String valued property that is used in the creation of the default string description of an object. Accessed by the built-in method <emu-xref href="#sec-object.prototype.tostring">`Object.prototype.toString`</emu-xref>.
  924.               </td>
  925.             </tr>
  926.             <tr>
  927.               <td>
  928.                 @@unscopables
  929.               </td>
  930.               <td>
  931.                 `"Symbol.unscopables"`
  932.               </td>
  933.               <td>
  934.                 An object valued property whose own and inherited property names are property names that are excluded from the `with` environment bindings of the associated object.
  935.               </td>
  936.             </tr>
  937.             </tbody>
  938.           </table>
  939.         </emu-table>
  940.       </emu-clause>
  941.     </emu-clause>
  943.     <!-- es6num="6.1.6" -->
  944.     <emu-clause id="sec-ecmascript-language-types-number-type">
  945.       <h1>The Number Type</h1>
  946.       <p>The Number type has exactly 18437736874454810627 (that is, <emu-eqn>2<sup>64</sup>-2<sup>53</sup>+3</emu-eqn>) values, representing the double-precision 64-bit format IEEE 754-2008 values as specified in the IEEE Standard for Binary Floating-Point Arithmetic, except that the 9007199254740990 (that is, <emu-eqn>2<sup>53</sup>-2</emu-eqn>) distinct &ldquo;Not-a-Number&rdquo; values of the IEEE Standard are represented in ECMAScript as a single special *NaN* value. (Note that the *NaN* value is produced by the program expression `NaN`.) In some implementations, external code might be able to detect a difference between various Not-a-Number values, but such behaviour is implementation-dependent; to ECMAScript code, all *NaN* values are indistinguishable from each other.</p>
  947.       <emu-note>
  948.         <p>The bit pattern that might be observed in an ArrayBuffer (see <emu-xref href="#sec-arraybuffer-objects"></emu-xref>) after a Number value has been stored into it is not necessarily the same as the internal representation of that Number value used by the ECMAScript implementation.</p>
  949.       </emu-note>
  950.       <p>There are two other special values, called *positive Infinity* and *negative Infinity*. For brevity, these values are also referred to for expository purposes by the symbols *+&infin;* and *-&infin;*, respectively. (Note that these two infinite Number values are produced by the program expressions `+Infinity` (or simply `Infinity`) and `-Infinity`.)</p>
  951.       <p>The other 18437736874454810624 (that is, <emu-eqn>2<sup>64</sup>-2<sup>53</sup></emu-eqn>) values are called the finite numbers. Half of these are positive numbers and half are negative numbers; for every finite positive Number value there is a corresponding negative value having the same magnitude.</p>
  952.       <p>Note that there is both a *positive zero* and a *negative zero*. For brevity, these values are also referred to for expository purposes by the symbols *+0* and *-0*, respectively. (Note that these two different zero Number values are produced by the program expressions `+0` (or simply `0`) and `-0`.)</p>
  953.       <p>The 18437736874454810622 (that is, <emu-eqn>2<sup>64</sup>-2<sup>53</sup>-2</emu-eqn>) finite nonzero values are of two kinds:</p>
  954.       <p>18428729675200069632 (that is, <emu-eqn>2<sup>64</sup>-2<sup>54</sup></emu-eqn>) of them are normalized, having the form</p>
  955.       <div class="math-display">
  956.         _s_ &times; _m_ &times; 2<sup>_e_</sup>
  957.       </div>
  958.       <p>where _s_ is +1 or -1, _m_ is a positive integer less than 2<sup>53</sup> but not less than 2<sup>52</sup>, and _e_ is an integer ranging from -1074 to 971, inclusive.</p>
  959.       <p>The remaining 9007199254740990 (that is, <emu-eqn>2<sup>53</sup>-2</emu-eqn>) values are denormalized, having the form</p>
  960.       <div class="math-display">
  961.         _s_ &times; _m_ &times; 2<sup>_e_</sup>
  962.       </div>
  963.       <p>where _s_ is +1 or -1, _m_ is a positive integer less than 2<sup>52</sup>, and _e_ is -1074.</p>
  964.       <p>Note that all the positive and negative integers whose magnitude is no greater than 2<sup>53</sup> are representable in the Number type (indeed, the integer 0 has two representations, *+0* and *-0*).</p>
  965.       <p>A finite number has an <em>odd significand</em> if it is nonzero and the integer _m_ used to express it (in one of the two forms shown above) is odd. Otherwise, it has an <em>even significand</em>.</p>
  966.       <p>In this specification, the phrase &ldquo;the Number value for _x_&rdquo; where _x_ represents an exact nonzero real mathematical quantity (which might even be an irrational number such as &pi;) means a Number value chosen in the following manner. Consider the set of all finite values of the Number type, with *-0* removed and with two additional values added to it that are not representable in the Number type, namely 2<sup>1024</sup> (which is <emu-eqn>+1 &times; 2<sup>53</sup> &times; 2<sup>971</sup></emu-eqn>) and <emu-eqn>-2<sup>1024</sup></emu-eqn> (which is <emu-eqn>-1 &times; 2<sup>53</sup> &times; 2<sup>971</sup></emu-eqn>). Choose the member of this set that is closest in value to _x_. If two values of the set are equally close, then the one with an even significand is chosen; for this purpose, the two extra values 2<sup>1024</sup> and <emu-eqn>-2<sup>1024</sup></emu-eqn> are considered to have even significands. Finally, if 2<sup>1024</sup> was chosen, replace it with *+&infin;*; if <emu-eqn>-2<sup>1024</sup></emu-eqn> was chosen, replace it with *-&infin;*; if *+0* was chosen, replace it with *-0* if and only if _x_ is less than zero; any other chosen value is used unchanged. The result is the Number value for _x_. (This procedure corresponds exactly to the behaviour of the IEEE 754-2008 &ldquo;round to nearest, ties to even&rdquo; mode.)</p>
  967.       <p>Some ECMAScript operators deal only with integers in specific ranges such as <emu-eqn>-2<sup>31</sup></emu-eqn> through <emu-eqn>2<sup>31</sup>-1</emu-eqn>, inclusive, or in the range 0 through <emu-eqn>2<sup>16</sup>-1</emu-eqn>, inclusive. These operators accept any value of the Number type but first convert each such value to an integer value in the expected range. See the descriptions of the numeric conversion operations in <emu-xref href="#sec-type-conversion"></emu-xref>.</p>
  968.     </emu-clause>
  970.     <!-- es6num="6.1.7" -->
  971.     <emu-clause id="sec-object-type">
  972.       <h1>The Object Type</h1>
  973.       <p>An Object is logically a collection of properties. Each property is either a data property, or an accessor property:</p>
  974.       <ul>
  975.         <li>
  976.           A <em>data property</em> associates a key value with an ECMAScript language value and a set of Boolean attributes.
  977.         </li>
  978.         <li>
  979.           An <em>accessor property</em> associates a key value with one or two accessor functions, and a set of Boolean attributes. The accessor functions are used to store or retrieve an ECMAScript language value that is associated with the property.
  980.         </li>
  981.       </ul>
  982.       <p>Properties are identified using key values. A property key value is either an ECMAScript String value or a Symbol value. All String and Symbol values, including the empty string, are valid as property keys. A <em>property name</em> is a property key that is a String value.</p>
  983.       <p>An <em>integer index</em> is a String-valued property key that is a canonical numeric String (see <emu-xref href="#sec-canonicalnumericindexstring"></emu-xref>) and whose numeric value is either *+0* or a positive integer &le; 2<sup>53</sup>-1. An <em>array index</em> is an integer index whose numeric value _i_ is in the range <emu-eqn>+0 &le; _i_ &lt; 2<sup>32</sup>-1</emu-eqn>.</p>
  984.       <p>Property keys are used to access properties and their values. There are two kinds of access for properties: <em>get</em> and <em>set</em>, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both <em>own properties</em> that are a direct part of an object and <em>inherited properties</em> which are provided by another associated object via a property inheritance relationship. Inherited properties may be either own or inherited properties of the associated object. Each own property of an object must each have a key value that is distinct from the key values of the other own properties of that object.</p>
  985.       <p>All objects are logically collections of properties, but there are multiple forms of objects that differ in their semantics for accessing and manipulating their properties. <em>Ordinary objects</em> are the most common form of objects and have the default object semantics. An <em>exotic object</em> is any form of object whose property semantics differ in any way from the default semantics.</p>
  987.       <!-- es6num="" -->
  988.       <emu-clause id="sec-property-attributes">
  989.         <h1>Property Attributes</h1>
  990.         <p>Attributes are used in this specification to define and explain the state of Object properties. A data property associates a key value with the attributes listed in <emu-xref href="#table-2"></emu-xref>.</p>
  991.         <emu-table id="table-2" caption="Attributes of a Data Property">
  992.           <table>
  993.             <tbody>
  994.             <tr>
  995.               <th>
  996.                 Attribute Name
  997.               </th>
  998.               <th>
  999.                 Value Domain
  1000.               </th>
  1001.               <th>
  1002.                 Description
  1003.               </th>
  1004.             </tr>
  1005.             <tr>
  1006.               <td>
  1007.                 [[Value]]
  1008.               </td>
  1009.               <td>
  1010.                 Any ECMAScript language type
  1011.               </td>
  1012.               <td>
  1013.                 The value retrieved by a get access of the property.
  1014.               </td>
  1015.             </tr>
  1016.             <tr>
  1017.               <td>
  1018.                 [[Writable]]
  1019.               </td>
  1020.               <td>
  1021.                 Boolean
  1022.               </td>
  1023.               <td>
  1024.                 If *false*, attempts by ECMAScript code to change the property's [[Value]] attribute using [[Set]] will not succeed.
  1025.               </td>
  1026.             </tr>
  1027.             <tr>
  1028.               <td>
  1029.                 [[Enumerable]]
  1030.               </td>
  1031.               <td>
  1032.                 Boolean
  1033.               </td>
  1034.               <td>
  1035.                 If *true*, the property will be enumerated by a for-in enumeration (see <emu-xref href="#sec-for-in-and-for-of-statements"></emu-xref>). Otherwise, the property is said to be non-enumerable.
  1036.               </td>
  1037.             </tr>
  1038.             <tr>
  1039.               <td>
  1040.                 [[Configurable]]
  1041.               </td>
  1042.               <td>
  1043.                 Boolean
  1044.               </td>
  1045.               <td>
  1046.                 If *false*, attempts to delete the property, change the property to be an accessor property, or change its attributes (other than [[Value]], or changing [[Writable]] to *false*) will fail.
  1047.               </td>
  1048.             </tr>
  1049.             </tbody>
  1050.           </table>
  1051.         </emu-table>
  1052.         <p>An accessor property associates a key value with the attributes listed in <emu-xref href="#table-3"></emu-xref>.</p>
  1053.         <emu-table id="table-3" caption="Attributes of an Accessor Property">
  1054.           <table>
  1055.             <tbody>
  1056.             <tr>
  1057.               <th>
  1058.                 Attribute Name
  1059.               </th>
  1060.               <th>
  1061.                 Value Domain
  1062.               </th>
  1063.               <th>
  1064.                 Description
  1065.               </th>
  1066.             </tr>
  1067.             <tr>
  1068.               <td>
  1069.                 [[Get]]
  1070.               </td>
  1071.               <td>
  1072.                 Object | Undefined
  1073.               </td>
  1074.               <td>
  1075.                 If the value is an Object it must be a function object. The function's [[Call]] internal method (<emu-xref href="#table-6"></emu-xref>) is called with an empty arguments list to retrieve the property value each time a get access of the property is performed.
  1076.               </td>
  1077.             </tr>
  1078.             <tr>
  1079.               <td>
  1080.                 [[Set]]
  1081.               </td>
  1082.               <td>
  1083.                 Object | Undefined
  1084.               </td>
  1085.               <td>
  1086.                 If the value is an Object it must be a function object. The function's [[Call]] internal method (<emu-xref href="#table-6"></emu-xref>) is called with an arguments list containing the assigned value as its sole argument each time a set access of the property is performed. The effect of a property's [[Set]] internal method may, but is not required to, have an effect on the value returned by subsequent calls to the property's [[Get]] internal method.
  1087.               </td>
  1088.             </tr>
  1089.             <tr>
  1090.               <td>
  1091.                 [[Enumerable]]
  1092.               </td>
  1093.               <td>
  1094.                 Boolean
  1095.               </td>
  1096.               <td>
  1097.                 If *true*, the property is to be enumerated by a for-in enumeration (see <emu-xref href="#sec-for-in-and-for-of-statements"></emu-xref>). Otherwise, the property is said to be non-enumerable.
  1098.               </td>
  1099.             </tr>
  1100.             <tr>
  1101.               <td>
  1102.                 [[Configurable]]
  1103.               </td>
  1104.               <td>
  1105.                 Boolean
  1106.               </td>
  1107.               <td>
  1108.                 If *false*, attempts to delete the property, change the property to be a data property, or change its attributes will fail.
  1109.               </td>
  1110.             </tr>
  1111.             </tbody>
  1112.           </table>
  1113.         </emu-table>
  1114.         <p>If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined in <emu-xref href="#table-4"></emu-xref> is used.</p>
  1115.         <emu-table id="table-4" caption="Default Attribute Values">
  1116.           <table>
  1117.             <tbody>
  1118.             <tr>
  1119.               <th>
  1120.                 Attribute Name
  1121.               </th>
  1122.               <th>
  1123.                 Default Value
  1124.               </th>
  1125.             </tr>
  1126.             <tr>
  1127.               <td>
  1128.                 [[Value]]
  1129.               </td>
  1130.               <td>
  1131.                 *undefined*
  1132.               </td>
  1133.             </tr>
  1134.             <tr>
  1135.               <td>
  1136.                 [[Get]]
  1137.               </td>
  1138.               <td>
  1139.                 *undefined*
  1140.               </td>
  1141.             </tr>
  1142.             <tr>
  1143.               <td>
  1144.                 [[Set]]
  1145.               </td>
  1146.               <td>
  1147.                 *undefined*
  1148.               </td>
  1149.             </tr>
  1150.             <tr>
  1151.               <td>
  1152.                 [[Writable]]
  1153.               </td>
  1154.               <td>
  1155.                 *false*
  1156.               </td>
  1157.             </tr>
  1158.             <tr>
  1159.               <td>
  1160.                 [[Enumerable]]
  1161.               </td>
  1162.               <td>
  1163.                 *false*
  1164.               </td>
  1165.             </tr>
  1166.             <tr>
  1167.               <td>
  1168.                 [[Configurable]]
  1169.               </td>
  1170.               <td>
  1171.                 *false*
  1172.               </td>
  1173.             </tr>
  1174.             </tbody>
  1175.           </table>
  1176.         </emu-table>
  1177.       </emu-clause>
  1179.       <!-- es6num="" -->
  1180.       <emu-clause id="sec-object-internal-methods-and-internal-slots">
  1181.         <h1>Object Internal Methods and Internal Slots</h1>
  1182.         <p>The actual semantics of objects, in ECMAScript, are specified via algorithms called <em>internal methods</em>. Each object in an ECMAScript engine is associated with a set of internal methods that defines its runtime behaviour. These internal methods are not part of the ECMAScript language. They are defined by this specification purely for expository purposes. However, each object within an implementation of ECMAScript must behave as specified by the internal methods associated with it. The exact manner in which this is accomplished is determined by the implementation.</p>
  1183.         <p>Internal method names are polymorphic. This means that different object values may perform different algorithms when a common internal method name is invoked upon them. That actual object upon which an internal method is invoked is the &ldquo;target&rdquo; of the invocation. If, at runtime, the implementation of an algorithm attempts to use an internal method of an object that the object does not support, a *TypeError* exception is thrown.</p>
  1184.         <p>Internal slots correspond to internal state that is associated with objects and used by various ECMAScript specification algorithms. Internal slots are not object properties and they are not inherited. Depending upon the specific internal slot specification, such state may consist of values of any ECMAScript language type or of specific ECMAScript specification type values. Unless explicitly specified otherwise, internal slots are allocated as part of the process of creating an object and may not be dynamically added to an object. Unless specified otherwise, the initial value of an internal slot is the value *undefined*. Various algorithms within this specification create objects that have internal slots. However, the ECMAScript language provides no direct way to associate internal slots with an object.</p>
  1185.         <p>Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].</p>
  1186.         <p><emu-xref href="#table-5"></emu-xref> summarizes the <em>essential internal methods</em> used by this specification that are applicable to all objects created or manipulated by ECMAScript code. Every object must have algorithms for all of the essential internal methods. However, all objects do not necessarily use the same algorithms for those methods.</p>
  1187.         <p>The &ldquo;Signature&rdquo; column of <emu-xref href="#table-5"></emu-xref> and other similar tables describes the invocation pattern for each internal method. The invocation pattern always includes a parenthesized list of descriptive parameter names. If a parameter name is the same as an ECMAScript type name then the name describes the required type of the parameter value. If an internal method explicitly returns a value, its parameter list is followed by the symbol &ldquo;&rarr;&rdquo; and the type name of the returned value. The type names used in signatures refer to the types defined in clause <emu-xref href="#sec-ecmascript-data-types-and-values"></emu-xref> augmented by the following additional names. &ldquo;<em>any</em>&rdquo; means the value may be any ECMAScript language type. An internal method implicitly returns a Completion Record. In addition to its parameters, an internal method always has access to the object that is the target of the method invocation.</p>
  1188.         <emu-table id="table-5" caption="Essential Internal Methods">
  1189.           <table>
  1190.             <tbody>
  1191.             <tr>
  1192.               <th>
  1193.                 Internal Method
  1194.               </th>
  1195.               <th>
  1196.                 Signature
  1197.               </th>
  1198.               <th>
  1199.                 Description
  1200.               </th>
  1201.             </tr>
  1202.             <tr>
  1203.               <td>
  1204.                 [[GetPrototypeOf]]
  1205.               </td>
  1206.               <td>
  1207.                 () <b>&rarr;</b> Object | Null
  1208.               </td>
  1209.               <td>
  1210.                 Determine the object that provides inherited properties for this object. A *null* value indicates that there are no inherited properties.
  1211.               </td>
  1212.             </tr>
  1213.             <tr>
  1214.               <td>
  1215.                 [[SetPrototypeOf]]
  1216.               </td>
  1217.               <td>
  1218.                 (Object | Null) <b>&rarr;</b> Boolean
  1219.               </td>
  1220.               <td>
  1221.                 Associate this object with another object that provides inherited properties. Passing *null* indicates that there are no inherited properties. Returns *true* indicating that the operation was completed successfully or *false* indicating that the operation was not successful.
  1222.               </td>
  1223.             </tr>
  1224.             <tr>
  1225.               <td>
  1226.                 [[IsExtensible]]
  1227.               </td>
  1228.               <td>
  1229.                 ( ) <b>&rarr;</b> Boolean
  1230.               </td>
  1231.               <td>
  1232.                 Determine whether it is permitted to add additional properties to this object.
  1233.               </td>
  1234.             </tr>
  1235.             <tr>
  1236.               <td>
  1237.                 [[PreventExtensions]]
  1238.               </td>
  1239.               <td>
  1240.                 ( ) <b>&rarr;</b> Boolean
  1241.               </td>
  1242.               <td>
  1243.                 Control whether new properties may be added to this object. Returns *true* if the operation was successful or *false* if the operation was unsuccessful.
  1244.               </td>
  1245.             </tr>
  1246.             <tr>
  1247.               <td>
  1248.                 [[GetOwnProperty]]
  1249.               </td>
  1250.               <td>
  1251.                 (_propertyKey_) <b>&rarr;</b> Undefined | Property Descriptor
  1252.               </td>
  1253.               <td>
  1254.                 Return a Property Descriptor for the own property of this object whose key is _propertyKey_, or *undefined* if no such property exists.
  1255.               </td>
  1256.             </tr>
  1257.             <tr>
  1258.               <td>
  1259.                 [[DefineOwnProperty]]
  1260.               </td>
  1261.               <td>
  1262.                 (_propertyKey_, _PropertyDescriptor_) <b>&rarr;</b> Boolean
  1263.               </td>
  1264.               <td>
  1265.                 Create or alter the own property, whose key is _propertyKey_, to have the state described by _PropertyDescriptor_. Return *true* if that property was successfully created/updated or *false* if the property could not be created or updated.
  1266.               </td>
  1267.             </tr>
  1268.             <tr>
  1269.               <td>
  1270.                 [[HasProperty]]
  1271.               </td>
  1272.               <td>
  1273.                 (_propertyKey_) <b>&rarr;</b> Boolean
  1274.               </td>
  1275.               <td>
  1276.                 Return a Boolean value indicating whether this object already has either an own or inherited property whose key is _propertyKey_.
  1277.               </td>
  1278.             </tr>
  1279.             <tr>
  1280.               <td>
  1281.                 [[Get]]
  1282.               </td>
  1283.               <td>
  1284.                 (_propertyKey_, _Receiver_) <b>&rarr;</b> <em>any</em>
  1285.               </td>
  1286.               <td>
  1287.                 Return the value of the property whose key is _propertyKey_ from this object. If any ECMAScript code must be executed to retrieve the property value, _Receiver_ is used as the *this* value when evaluating the code.
  1288.               </td>
  1289.             </tr>
  1290.             <tr>
  1291.               <td>
  1292.                 [[Set]]
  1293.               </td>
  1294.               <td>
  1295.                 (_propertyKey_, _value_, _Receiver_) <b>&rarr;</b> Boolean
  1296.               </td>
  1297.               <td>
  1298.                 Set the value of the property whose key is _propertyKey_ to _value_. If any ECMAScript code must be executed to set the property value, _Receiver_ is used as the *this* value when evaluating the code. Returns *true* if the property value was set or *false* if it could not be set.
  1299.               </td>
  1300.             </tr>
  1301.             <tr>
  1302.               <td>
  1303.                 [[Delete]]
  1304.               </td>
  1305.               <td>
  1306.                 (_propertyKey_) <b>&rarr;</b> Boolean
  1307.               </td>
  1308.               <td>
  1309.                 Remove the own property whose key is _propertyKey_ from this object. Return *false* if the property was not deleted and is still present. Return *true* if the property was deleted or is not present.
  1310.               </td>
  1311.             </tr>
  1312.             <tr>
  1313.               <td>
  1314.                 [[OwnPropertyKeys]]
  1315.               </td>
  1316.               <td>
  1317.                 ()<b>&rarr;</b>List of propertyKey
  1318.               </td>
  1319.               <td>
  1320.                 Return a List whose elements are all of the own property keys for the object.
  1321.               </td>
  1322.             </tr>
  1323.             </tbody>
  1324.           </table>
  1325.         </emu-table>
  1326.         <p><emu-xref href="#table-6"></emu-xref> summarizes additional essential internal methods that are supported by objects that may be called as functions. A <em>function object</em> is an object that supports the [[Call]] internal method. A <em>constructor</em> (also referred to as a <em>constructor function</em>) is a function object that supports the [[Construct]] internal method.</p>
  1327.         <emu-table id="table-6" caption="Additional Essential Internal Methods of Function Objects">
  1328.           <table>
  1329.             <tbody>
  1330.             <tr>
  1331.               <th>
  1332.                 Internal Method
  1333.               </th>
  1334.               <th>
  1335.                 Signature
  1336.               </th>
  1337.               <th>
  1338.                 Description
  1339.               </th>
  1340.             </tr>
  1341.             <tr>
  1342.               <td>
  1343.                 [[Call]]
  1344.               </td>
  1345.               <td>
  1346.                 (<em>any</em>, a List of <em>any</em>) <b>&rarr;</b> <em>any</em>
  1347.               </td>
  1348.               <td>
  1349.                 Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a *this* value and a list containing the arguments passed to the function by a call expression. Objects that implement this internal method are <em>callable</em>.
  1350.               </td>
  1351.             </tr>
  1352.             <tr>
  1353.               <td>
  1354.                 [[Construct]]
  1355.               </td>
  1356.               <td>
  1357.                 (a List of <em>any</em>, Object) <b>&rarr;</b> Object
  1358.               </td>
  1359.               <td>
  1360.                 Creates an object. Invoked via the `new` or `super` operators. The first argument to the internal method is a list containing the arguments of the operator. The second argument is the object to which the `new` operator was initially applied. Objects that implement this internal method are called <em>constructors</em>. A function object is not necessarily a constructor and such non-constructor function objects do not have a [[Construct]] internal method.
  1361.               </td>
  1362.             </tr>
  1363.             </tbody>
  1364.           </table>
  1365.         </emu-table>
  1366.         <p>The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause <emu-xref href="#sec-ordinary-and-exotic-objects-behaviours"></emu-xref>. If any specified use of an internal method of an exotic object is not supported by an implementation, that usage must throw a *TypeError* exception when attempted.</p>
  1367.       </emu-clause>
  1369.       <!-- es6num="" -->
  1370.       <emu-clause id="sec-invariants-of-the-essential-internal-methods">
  1371.         <h1>Invariants of the Essential Internal Methods</h1>
  1372.         <p>The Internal Methods of Objects of an ECMAScript engine must conform to the list of invariants specified below. Ordinary ECMAScript Objects as well as all standard exotic objects in this specification maintain these invariants. ECMAScript Proxy objects maintain these invariants by means of runtime checks on the result of traps invoked on the [[ProxyHandler]] object.</p>
  1373.         <p>Any implementation provided exotic objects must also maintain these invariants for those objects. Violation of these invariants may cause ECMAScript code to have unpredictable behaviour and create security issues. However, violation of these invariants must never compromise the memory safety of an implementation.</p>
  1374.         <p>An implementation must not allow these invariants to be circumvented in any manner such as by providing alternative interfaces that implement the functionality of the essential internal methods without enforcing their invariants.</p>
  1375.         <h2>Definitions:</h2>
  1376.         <ul>
  1377.           <li>
  1378.             The <em>target</em> of an internal method is the object upon which the internal method is called.
  1379.           </li>
  1380.           <li>
  1381.             A target is <em>non-extensible</em> if it has been observed to return false from its [[IsExtensible]] internal method, or true from its [[PreventExtensions]] internal method.
  1382.           </li>
  1383.           <li>
  1384.             A <em>non-existent</em> property is a property that does not exist as an own property on a non-extensible target.
  1385.           </li>
  1386.           <li>
  1387.             All references to <em>SameValue</em> are according to the definition of the SameValue algorithm.
  1388.           </li>
  1389.         </ul>
  1390.         <h2>[[GetPrototypeOf]] ( )</h2>
  1391.         <ul>
  1392.           <li>
  1393.             The Type of the return value must be either Object or Null.
  1394.           </li>
  1395.           <li>
  1396.             If target is non-extensible, and [[GetPrototypeOf]] returns a value v, then any future calls to [[GetPrototypeOf]] should return the SameValue as v.
  1397.           </li>
  1398.         </ul>
  1399.         <emu-note>
  1400.           <p>An object's prototype chain should have finite length (that is, starting from any object, recursively applying the [[GetPrototypeOf]] internal method to its result should eventually lead to the value null). However, this requirement is not enforceable as an object level invariant if the prototype chain includes any exotic objects that do not use the ordinary object definition of [[GetPrototypeOf]]. Such a circular prototype chain may result in infinite loops when accessing object properties.</p>
  1401.         </emu-note>
  1402.         <h2>[[SetPrototypeOf]] (_V_)</h2>
  1403.         <ul>
  1404.           <li>
  1405.             The Type of the return value must be Boolean.
  1406.           </li>
  1407.           <li>
  1408.             If target is non-extensible, [[SetPrototypeOf]] must return false, unless V is the SameValue as the target's observed [[GetPrototypeOf]] value.
  1409.           </li>
  1410.         </ul>
  1411.         <h2>[[IsExtensible]] ( )</h2>
  1412.         <ul>
  1413.           <li>
  1414.             The Type of the return value must be Boolean.
  1415.           </li>
  1416.           <li>
  1417.             If [[IsExtensible]] returns false, all future calls to [[IsExtensible]] on the target must return false.
  1418.           </li>
  1419.         </ul>
  1420.         <h2>[[PreventExtensions]] ( )</h2>
  1421.         <ul>
  1422.           <li>
  1423.             The Type of the return value must be Boolean.
  1424.           </li>
  1425.           <li>
  1426.             If [[PreventExtensions]] returns true, all future calls to [[IsExtensible]] on the target must return false and the target is now considered non-extensible.
  1427.           </li>
  1428.         </ul>
  1429.         <h2>[[GetOwnProperty]] (_P_)</h2>
  1430.         <ul>
  1431.           <li>
  1432.             The Type of the return value must be either Property Descriptor or Undefined.
  1433.           </li>
  1434.           <li>
  1435.             If the Type of the return value is Property Descriptor, the return value must be a complete property descriptor (see <emu-xref href="#sec-completepropertydescriptor"></emu-xref>).
  1436.           </li>
  1437.           <li>
  1438.             If a property P is described as a data property with Desc.[[Value]] equal to v and Desc.[[Writable]] and Desc.[[Configurable]] are both false, then the SameValue must be returned for the Desc.[[Value]] attribute of the property on all future calls to [[GetOwnProperty]] ( P ).
  1439.           </li>
  1440.           <li>
  1441.             If P's attributes other than [[Writable]] may change over time or if the property might disappear, then P's [[Configurable]] attribute must be true.
  1442.           </li>
  1443.           <li>
  1444.             If the [[Writable]] attribute may change from false to true, then the [[Configurable]] attribute must be true.
  1445.           </li>
  1446.           <li>
  1447.             If the target is non-extensible and P is non-existent, then all future calls to [[GetOwnProperty]] (P) on the target must describe P as non-existent (i.e. [[GetOwnProperty]] (P) must return undefined).
  1448.           </li>
  1449.         </ul>
  1450.         <emu-note>
  1451.           <p>As a consequence of the third invariant, if a property is described as a data property and it may return different values over time, then either or both of the Desc.[[Writable]] and Desc.[[Configurable]] attributes must be true even if no mechanism to change the value is exposed via the other internal methods.</p>
  1452.         </emu-note>
  1453.         <h2>[[DefineOwnProperty]] (_P_, _Desc_)</h2>
  1454.         <ul>
  1455.           <li>
  1456.             The Type of the return value must be Boolean.
  1457.           </li>
  1458.           <li>
  1459.             <p>[[DefineOwnProperty]] must return false if P has previously been observed as a non-configurable own property of the target, unless either:</p>
  1460.             <ol>
  1461.               <li>
  1462.                 P is a non-configurable writable own data property. A non-configurable writable data property can be changed into a non-configurable non-writable data property.
  1463.               </li>
  1464.               <li>
  1465.                 All attributes in Desc are the SameValue as P's attributes.
  1466.               </li>
  1467.             </ol>
  1468.           </li>
  1469.           <li>
  1470.             [[DefineOwnProperty]] (P, Desc) must return false if target is non-extensible and P is a non-existent own property. That is, a non-extensible target object cannot be extended with new properties.
  1471.           </li>
  1472.         </ul>
  1473.         <h2>[[HasProperty]] ( _P_ )</h2>
  1474.         <ul>
  1475.           <li>
  1476.             The Type of the return value must be Boolean.
  1477.           </li>
  1478.           <li>
  1479.             If P was previously observed as a non-configurable data or accessor own property of the target, [[HasProperty]] must return true.
  1480.           </li>
  1481.         </ul>
  1482.         <h2>[[Get]] (_P_, _Receiver_)</h2>
  1483.         <ul>
  1484.           <li>
  1485.             If P was previously observed as a non-configurable, non-writable own data property of the target with value v, then [[Get]] must return the SameValue.
  1486.           </li>
  1487.           <li>
  1488.             If P was previously observed as a non-configurable own accessor property of the target whose [[Get]] attribute is undefined, the [[Get]] operation must return undefined.
  1489.           </li>
  1490.         </ul>
  1491.         <h2>[[Set]] ( _P_, _V_, _Receiver_)</h2>
  1492.         <ul>
  1493.           <li>
  1494.             The Type of the return value must be Boolean.
  1495.           </li>
  1496.           <li>
  1497.             If P was previously observed as a non-configurable, non-writable own data property of the target, then [[Set]] must return false unless V is the SameValue as P's [[Value]] attribute.
  1498.           </li>
  1499.           <li>
  1500.             If P was previously observed as a non-configurable own accessor property of the target whose [[Set]] attribute is undefined, the [[Set]] operation must return false.
  1501.           </li>
  1502.         </ul>
  1503.         <h2>[[Delete]] ( _P_ )</h2>
  1504.         <ul>
  1505.           <li>
  1506.             The Type of the return value must be Boolean.
  1507.           </li>
  1508.           <li>
  1509.             If P was previously observed to be a non-configurable own data or accessor property of the target, [[Delete]] must return false.
  1510.           </li>
  1511.         </ul>
  1512.         <h2>[[OwnPropertyKeys]] ( )</h2>
  1513.         <ul>
  1514.           <li>
  1515.             The return value must be a List.
  1516.           </li>
  1517.           <li>
  1518.             The Type of each element of the returned List is either String or Symbol.
  1519.           </li>
  1520.           <li>
  1521.             The returned List must contain at least the keys of all non-configurable own properties that have previously been observed.
  1522.           </li>
  1523.           <li>
  1524.             If the object is non-extensible, the returned List must contain only the keys of all own properties of the object that are observable using [[GetOwnProperty]].
  1525.           </li>
  1526.         </ul>
  1527.         <h2>[[Construct]] ( )</h2>
  1528.         <ul>
  1529.           <li>
  1530.             The Type of the return value must be Object.
  1531.           </li>
  1532.         </ul>
  1533.       </emu-clause>
  1535.       <!-- es6num="" -->
  1536.       <emu-clause id="sec-well-known-intrinsic-objects">
  1537.         <h1>Well-Known Intrinsic Objects</h1>
  1538.         <p>Well-known intrinsics are built-in objects that are explicitly referenced by the algorithms of this specification and which usually have realm-specific identities. Unless otherwise specified each intrinsic object actually corresponds to a set of similar objects, one per realm.</p>
  1539.         <p>Within this specification a reference such as %name% means the intrinsic object, associated with the current realm, corresponding to the name. Determination of the current realm and its intrinsics is described in <emu-xref href="#sec-execution-contexts"></emu-xref>. The well-known intrinsics are listed in <emu-xref href="#table-7"></emu-xref>.</p>
  1540.         <emu-table id="table-7" caption="Well-known Intrinsic Objects">
  1541.           <table>
  1542.             <tbody>
  1543.             <tr>
  1544.               <th>
  1545.                 Intrinsic Name
  1546.               </th>
  1547.               <th>
  1548.                 Global Name
  1549.               </th>
  1550.               <th>
  1551.                 ECMAScript Language Association
  1552.               </th>
  1553.             </tr>
  1554.             <tr>
  1555.               <td>
  1556.                 %Array%
  1557.               </td>
  1558.               <td>
  1559.                 `Array`
  1560.               </td>
  1561.               <td>
  1562.                 The `Array` constructor (<emu-xref href="#sec-array-constructor"></emu-xref>)
  1563.               </td>
  1564.             </tr>
  1565.             <tr>
  1566.               <td>
  1567.                 %ArrayBuffer%
  1568.               </td>
  1569.               <td>
  1570.                 `ArrayBuffer`
  1571.               </td>
  1572.               <td>
  1573.                 The `ArrayBuffer` constructor (<emu-xref href="#sec-arraybuffer-constructor"></emu-xref>)
  1574.               </td>
  1575.             </tr>
  1576.             <tr>
  1577.               <td>
  1578.                 %ArrayBufferPrototype%
  1579.               </td>
  1580.               <td>
  1581.                 `ArrayBuffer.prototype`
  1582.               </td>
  1583.               <td>
  1584.                 The initial value of the `prototype` data property of %ArrayBuffer%.
  1585.               </td>
  1586.             </tr>
  1587.             <tr>
  1588.               <td>
  1589.                 %ArrayIteratorPrototype%
  1590.               </td>
  1591.               <td>
  1592.               </td>
  1593.               <td>
  1594.                 The prototype of Array iterator objects (<emu-xref href="#sec-array-iterator-objects"></emu-xref>)
  1595.               </td>
  1596.             </tr>
  1597.             <tr>
  1598.               <td>
  1599.                 %ArrayPrototype%
  1600.               </td>
  1601.               <td>
  1602.                 `Array.prototype`
  1603.               </td>
  1604.               <td>
  1605.                 The initial value of the `prototype` data property of %Array% (<emu-xref href="#sec-properties-of-the-array-prototype-object"></emu-xref>)
  1606.               </td>
  1607.             </tr>
  1608.             <tr>
  1609.               <td>
  1610.                 %ArrayProto_values%
  1611.               </td>
  1612.               <td>
  1613.                 `Array.prototype.values`
  1614.               </td>
  1615.               <td>
  1616.                 The initial value of the `values` data property of %ArrayPrototype% (<emu-xref href="#sec-array.prototype.values"></emu-xref>)
  1617.               </td>
  1618.             </tr>
  1619.             <tr>
  1620.               <td>
  1621.                 %Boolean%
  1622.               </td>
  1623.               <td>
  1624.                 `Boolean`
  1625.               </td>
  1626.               <td>
  1627.                 The `Boolean` constructor (<emu-xref href="#sec-boolean-constructor"></emu-xref>)
  1628.               </td>
  1629.             </tr>
  1630.             <tr>
  1631.               <td>
  1632.                 %BooleanPrototype%
  1633.               </td>
  1634.               <td>
  1635.                 `Boolean.prototype`
  1636.               </td>
  1637.               <td>
  1638.                 The initial value of the `prototype` data property of %Boolean% (<emu-xref href="#sec-properties-of-the-boolean-prototype-object"></emu-xref>)
  1639.               </td>
  1640.             </tr>
  1641.             <tr>
  1642.               <td>
  1643.                 %DataView%
  1644.               </td>
  1645.               <td>
  1646.                 `DataView`
  1647.               </td>
  1648.               <td>
  1649.                 The `DataView` constructor (<emu-xref href="#sec-dataview-constructor"></emu-xref>)
  1650.               </td>
  1651.             </tr>
  1652.             <tr>
  1653.               <td>
  1654.                 %DataViewPrototype%
  1655.               </td>
  1656.               <td>
  1657.                 `DataView.prototype`
  1658.               </td>
  1659.               <td>
  1660.                 The initial value of the `prototype` data property of %DataView%
  1661.               </td>
  1662.             </tr>
  1663.             <tr>
  1664.               <td>
  1665.                 %Date%
  1666.               </td>
  1667.               <td>
  1668.                 `Date`
  1669.               </td>
  1670.               <td>
  1671.                 The `Date` constructor (<emu-xref href="#sec-date-constructor"></emu-xref>)
  1672.               </td>
  1673.             </tr>
  1674.             <tr>
  1675.               <td>
  1676.                 %DatePrototype%
  1677.               </td>
  1678.               <td>
  1679.                 `Date.prototype`
  1680.               </td>
  1681.               <td>
  1682.                 The initial value of the `prototype` data property of %Date%.
  1683.               </td>
  1684.             </tr>
  1685.             <tr>
  1686.               <td>
  1687.                 %decodeURI%
  1688.               </td>
  1689.               <td>
  1690.                 `decodeURI`
  1691.               </td>
  1692.               <td>
  1693.                 The `decodeURI` function (<emu-xref href="#sec-decodeuri-encodeduri"></emu-xref>)
  1694.               </td>
  1695.             </tr>
  1696.             <tr>
  1697.               <td>
  1698.                 %decodeURIComponent%
  1699.               </td>
  1700.               <td>
  1701.                 `decodeURIComponent`
  1702.               </td>
  1703.               <td>
  1704.                 The `decodeURIComponent` function (<emu-xref href="#sec-decodeuricomponent-encodeduricomponent"></emu-xref>)
  1705.               </td>
  1706.             </tr>
  1707.             <tr>
  1708.               <td>
  1709.                 %encodeURI%
  1710.               </td>
  1711.               <td>
  1712.                 `encodeURI`
  1713.               </td>
  1714.               <td>
  1715.                 The `encodeURI` function (<emu-xref href="#sec-encodeuri-uri"></emu-xref>)
  1716.               </td>
  1717.             </tr>
  1718.             <tr>
  1719.               <td>
  1720.                 %encodeURIComponent%
  1721.               </td>
  1722.               <td>
  1723.                 `encodeURIComponent`
  1724.               </td>
  1725.               <td>
  1726.                 The `encodeURIComponent` function (<emu-xref href="#sec-encodeuricomponent-uricomponent"></emu-xref>)
  1727.               </td>
  1728.             </tr>
  1729.             <tr>
  1730.               <td>
  1731.                 %Error%
  1732.               </td>
  1733.               <td>
  1734.                 `Error`
  1735.               </td>
  1736.               <td>
  1737.                 The `Error` constructor (<emu-xref href="#sec-error-constructor"></emu-xref>)
  1738.               </td>
  1739.             </tr>
  1740.             <tr>
  1741.               <td>
  1742.                 %ErrorPrototype%
  1743.               </td>
  1744.               <td>
  1745.                 `Error.prototype`
  1746.               </td>
  1747.               <td>
  1748.                 The initial value of the `prototype` data property of %Error%
  1749.               </td>
  1750.             </tr>
  1751.             <tr>
  1752.               <td>
  1753.                 %eval%
  1754.               </td>
  1755.               <td>
  1756.                 `eval`
  1757.               </td>
  1758.               <td>
  1759.                 The `eval` function (<emu-xref href="#sec-eval-x"></emu-xref>)
  1760.               </td>
  1761.             </tr>
  1762.             <tr>
  1763.               <td>
  1764.                 %EvalError%
  1765.               </td>
  1766.               <td>
  1767.                 `EvalError`
  1768.               </td>
  1769.               <td>
  1770.                 The `EvalError` constructor (<emu-xref href="#sec-native-error-types-used-in-this-standard-evalerror"></emu-xref>)
  1771.               </td>
  1772.             </tr>
  1773.             <tr>
  1774.               <td>
  1775.                 %EvalErrorPrototype%
  1776.               </td>
  1777.               <td>
  1778.                 `EvalError.prototype`
  1779.               </td>
  1780.               <td>
  1781.                 The initial value of the `prototype` property of %EvalError%
  1782.               </td>
  1783.             </tr>
  1784.             <tr>
  1785.               <td>
  1786.                 %Float32Array%
  1787.               </td>
  1788.               <td>
  1789.                 `Float32Array`
  1790.               </td>
  1791.               <td>
  1792.                 The `Float32Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  1793.               </td>
  1794.             </tr>
  1795.             <tr>
  1796.               <td>
  1797.                 %Float32ArrayPrototype%
  1798.               </td>
  1799.               <td>
  1800.                 `Float32Array.prototype`
  1801.               </td>
  1802.               <td>
  1803.                 The initial value of the `prototype` data property of %Float32Array%.
  1804.               </td>
  1805.             </tr>
  1806.             <tr>
  1807.               <td>
  1808.                 %Float64Array%
  1809.               </td>
  1810.               <td>
  1811.                 `Float64Array`
  1812.               </td>
  1813.               <td>
  1814.                 The `Float64Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  1815.               </td>
  1816.             </tr>
  1817.             <tr>
  1818.               <td>
  1819.                 %Float64ArrayPrototype%
  1820.               </td>
  1821.               <td>
  1822.                 `Float64Array.prototype`
  1823.               </td>
  1824.               <td>
  1825.                 The initial value of the `prototype` data property of %Float64Array%
  1826.               </td>
  1827.             </tr>
  1828.             <tr>
  1829.               <td>
  1830.                 %Function%
  1831.               </td>
  1832.               <td>
  1833.                 `Function`
  1834.               </td>
  1835.               <td>
  1836.                 The `Function` constructor (<emu-xref href="#sec-function-constructor"></emu-xref>)
  1837.               </td>
  1838.             </tr>
  1839.             <tr>
  1840.               <td>
  1841.                 %FunctionPrototype%
  1842.               </td>
  1843.               <td>
  1844.                 `Function.prototype`
  1845.               </td>
  1846.               <td>
  1847.                 The initial value of the `prototype` data property of %Function%
  1848.               </td>
  1849.             </tr>
  1850.             <tr>
  1851.               <td>
  1852.                 %Generator%
  1853.               </td>
  1854.               <td>
  1855.               </td>
  1856.               <td>
  1857.                 The initial value of the `prototype` property of %GeneratorFunction%
  1858.               </td>
  1859.             </tr>
  1860.             <tr>
  1861.               <td>
  1862.                 %GeneratorFunction%
  1863.               </td>
  1864.               <td>
  1865.               </td>
  1866.               <td>
  1867.                 The constructor of generator objects (<emu-xref href="#sec-generatorfunction-constructor"></emu-xref>)
  1868.               </td>
  1869.             </tr>
  1870.             <tr>
  1871.               <td>
  1872.                 %GeneratorPrototype%
  1873.               </td>
  1874.               <td>
  1875.               </td>
  1876.               <td>
  1877.                 The initial value of the `prototype` property of %Generator%
  1878.               </td>
  1879.             </tr>
  1880.             <tr>
  1881.               <td>
  1882.                 %AsyncFunction%
  1883.               </td>
  1884.               <td>
  1885.               </td>
  1886.               <td>
  1887.                 The constructor of async function objects (<emu-xref href="#sec-async-function-constructor"></emu-xref>)
  1888.               </td>
  1889.             </tr>
  1890.             <tr>
  1891.               <td>
  1892.                 %Int8Array%
  1893.               </td>
  1894.               <td>
  1895.                 `Int8Array`
  1896.               </td>
  1897.               <td>
  1898.                 The `Int8Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  1899.               </td>
  1900.             </tr>
  1901.             <tr>
  1902.               <td>
  1903.                 %Int8ArrayPrototype%
  1904.               </td>
  1905.               <td>
  1906.                 `Int8Array.prototype`
  1907.               </td>
  1908.               <td>
  1909.                 The initial value of the `prototype` data property of %Int8Array%
  1910.               </td>
  1911.             </tr>
  1912.             <tr>
  1913.               <td>
  1914.                 %Int16Array%
  1915.               </td>
  1916.               <td>
  1917.                 `Int16Array`
  1918.               </td>
  1919.               <td>
  1920.                 The `Int16Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  1921.               </td>
  1922.             </tr>
  1923.             <tr>
  1924.               <td>
  1925.                 %Int16ArrayPrototype%
  1926.               </td>
  1927.               <td>
  1928.                 `Int16Array.prototype`
  1929.               </td>
  1930.               <td>
  1931.                 The initial value of the `prototype` data property of %Int16Array%
  1932.               </td>
  1933.             </tr>
  1934.             <tr>
  1935.               <td>
  1936.                 %Int32Array%
  1937.               </td>
  1938.               <td>
  1939.                 `Int32Array`
  1940.               </td>
  1941.               <td>
  1942.                 The `Int32Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  1943.               </td>
  1944.             </tr>
  1945.             <tr>
  1946.               <td>
  1947.                 %Int32ArrayPrototype%
  1948.               </td>
  1949.               <td>
  1950.                 `Int32Array.prototype`
  1951.               </td>
  1952.               <td>
  1953.                 The initial value of the `prototype` data property of %Int32Array%
  1954.               </td>
  1955.             </tr>
  1956.             <tr>
  1957.               <td>
  1958.                 %isFinite%
  1959.               </td>
  1960.               <td>
  1961.                 `isFinite`
  1962.               </td>
  1963.               <td>
  1964.                 The `isFinite` function (<emu-xref href="#sec-isfinite-number"></emu-xref>)
  1965.               </td>
  1966.             </tr>
  1967.             <tr>
  1968.               <td>
  1969.                 %isNaN%
  1970.               </td>
  1971.               <td>
  1972.                 `isNaN`
  1973.               </td>
  1974.               <td>
  1975.                 The `isNaN` function (<emu-xref href="#sec-isnan-number"></emu-xref>)
  1976.               </td>
  1977.             </tr>
  1978.             <tr>
  1979.               <td>
  1980.                 %IteratorPrototype%
  1981.               </td>
  1982.               <td>
  1983.               </td>
  1984.               <td>
  1985.                 An object that all standard built-in iterator objects indirectly inherit from
  1986.               </td>
  1987.             </tr>
  1988.             <tr>
  1989.               <td>
  1990.                 %JSON%
  1991.               </td>
  1992.               <td>
  1993.                 `JSON`
  1994.               </td>
  1995.               <td>
  1996.                 The `JSON` object (<emu-xref href="#sec-json-object"></emu-xref>)
  1997.               </td>
  1998.             </tr>
  1999.             <tr>
  2000.               <td>
  2001.                 %Map%
  2002.               </td>
  2003.               <td>
  2004.                 `Map`
  2005.               </td>
  2006.               <td>
  2007.                 The `Map` constructor (<emu-xref href="#sec-map-constructor"></emu-xref>)
  2008.               </td>
  2009.             </tr>
  2010.             <tr>
  2011.               <td>
  2012.                 %MapIteratorPrototype%
  2013.               </td>
  2014.               <td>
  2015.               </td>
  2016.               <td>
  2017.                 The prototype of Map iterator objects (<emu-xref href="#sec-map-iterator-objects"></emu-xref>)
  2018.               </td>
  2019.             </tr>
  2020.             <tr>
  2021.               <td>
  2022.                 %MapPrototype%
  2023.               </td>
  2024.               <td>
  2025.                 `Map.prototype`
  2026.               </td>
  2027.               <td>
  2028.                 The initial value of the `prototype` data property of %Map%
  2029.               </td>
  2030.             </tr>
  2031.             <tr>
  2032.               <td>
  2033.                 %Math%
  2034.               </td>
  2035.               <td>
  2036.                 `Math`
  2037.               </td>
  2038.               <td>
  2039.                 The `Math` object (<emu-xref href="#sec-math-object"></emu-xref>)
  2040.               </td>
  2041.             </tr>
  2042.             <tr>
  2043.               <td>
  2044.                 %Number%
  2045.               </td>
  2046.               <td>
  2047.                 `Number`
  2048.               </td>
  2049.               <td>
  2050.                 The `Number` constructor (<emu-xref href="#sec-number-constructor"></emu-xref>)
  2051.               </td>
  2052.             </tr>
  2053.             <tr>
  2054.               <td>
  2055.                 %NumberPrototype%
  2056.               </td>
  2057.               <td>
  2058.                 `Number.prototype`
  2059.               </td>
  2060.               <td>
  2061.                 The initial value of the `prototype` property of %Number%
  2062.               </td>
  2063.             </tr>
  2064.             <tr>
  2065.               <td>
  2066.                 %Object%
  2067.               </td>
  2068.               <td>
  2069.                 `Object`
  2070.               </td>
  2071.               <td>
  2072.                 The `Object` constructor (<emu-xref href="#sec-object-constructor"></emu-xref>)
  2073.               </td>
  2074.             </tr>
  2075.             <tr>
  2076.               <td>
  2077.                 %ObjectPrototype%
  2078.               </td>
  2079.               <td>
  2080.                 `Object.prototype`
  2081.               </td>
  2082.               <td>
  2083.                 The initial value of the `prototype` data property of %Object%. (<emu-xref href="#sec-properties-of-the-object-prototype-object"></emu-xref>)
  2084.               </td>
  2085.             </tr>
  2086.             <tr>
  2087.               <td>
  2088.                 %ObjProto_toString%
  2089.               </td>
  2090.               <td>
  2091.                 `Object.prototype.toString`
  2092.               </td>
  2093.               <td>
  2094.                 The initial value of the `toString` data property of %ObjectPrototype% (<emu-xref href="#sec-object.prototype.tostring"></emu-xref>)
  2095.               </td>
  2096.             </tr>
  2097.             <tr>
  2098.               <td>
  2099.                 %ObjProto_valueOf%
  2100.               </td>
  2101.               <td>
  2102.                 `Object.prototype.valueOf`
  2103.               </td>
  2104.               <td>
  2105.                 The initial value of the `valueOf` data property of %ObjectPrototype% (<emu-xref href="#sec-object.prototype.valueof"></emu-xref>)
  2106.               </td>
  2107.             </tr>
  2108.             <tr>
  2109.               <td>
  2110.                 %parseFloat%
  2111.               </td>
  2112.               <td>
  2113.                 `parseFloat`
  2114.               </td>
  2115.               <td>
  2116.                 The `parseFloat` function (<emu-xref href="#sec-parsefloat-string"></emu-xref>)
  2117.               </td>
  2118.             </tr>
  2119.             <tr>
  2120.               <td>
  2121.                 %parseInt%
  2122.               </td>
  2123.               <td>
  2124.                 `parseInt`
  2125.               </td>
  2126.               <td>
  2127.                 The `parseInt` function (<emu-xref href="#sec-parseint-string-radix"></emu-xref>)
  2128.               </td>
  2129.             </tr>
  2130.             <tr>
  2131.               <td>
  2132.                 %Promise%
  2133.               </td>
  2134.               <td>
  2135.                 `Promise`
  2136.               </td>
  2137.               <td>
  2138.                 The `Promise` constructor (<emu-xref href="#sec-promise-constructor"></emu-xref>)
  2139.               </td>
  2140.             </tr>
  2141.             <tr>
  2142.               <td>
  2143.                 %PromisePrototype%
  2144.               </td>
  2145.               <td>
  2146.                 `Promise.prototype`
  2147.               </td>
  2148.               <td>
  2149.                 The initial value of the `prototype` data property of %Promise%
  2150.               </td>
  2151.             </tr>
  2152.             <tr>
  2153.               <td>
  2154.                 %Proxy%
  2155.               </td>
  2156.               <td>
  2157.                 `Proxy`
  2158.               </td>
  2159.               <td>
  2160.                 The `Proxy` constructor (<emu-xref href="#sec-proxy-constructor"></emu-xref>)
  2161.               </td>
  2162.             </tr>
  2163.             <tr>
  2164.               <td>
  2165.                 %RangeError%
  2166.               </td>
  2167.               <td>
  2168.                 `RangeError`
  2169.               </td>
  2170.               <td>
  2171.                 The `RangeError` constructor (<emu-xref href="#sec-native-error-types-used-in-this-standard-rangeerror"></emu-xref>)
  2172.               </td>
  2173.             </tr>
  2174.             <tr>
  2175.               <td>
  2176.                 %RangeErrorPrototype%
  2177.               </td>
  2178.               <td>
  2179.                 `RangeError.prototype`
  2180.               </td>
  2181.               <td>
  2182.                 The initial value of the `prototype` property of %RangeError%
  2183.               </td>
  2184.             </tr>
  2185.             <tr>
  2186.               <td>
  2187.                 %ReferenceError%
  2188.               </td>
  2189.               <td>
  2190.                 `ReferenceError`
  2191.               </td>
  2192.               <td>
  2193.                 The `ReferenceError` constructor (<emu-xref href="#sec-native-error-types-used-in-this-standard-referenceerror"></emu-xref>)
  2194.               </td>
  2195.             </tr>
  2196.             <tr>
  2197.               <td>
  2198.                 %ReferenceErrorPrototype%
  2199.               </td>
  2200.               <td>
  2201.                 `ReferenceError.prototype`
  2202.               </td>
  2203.               <td>
  2204.                 The initial value of the `prototype` property of %ReferenceError%
  2205.               </td>
  2206.             </tr>
  2207.             <tr>
  2208.               <td>
  2209.                 %Reflect%
  2210.               </td>
  2211.               <td>
  2212.                 `Reflect`
  2213.               </td>
  2214.               <td>
  2215.                 The `Reflect` object (<emu-xref href="#sec-reflect-object"></emu-xref>)
  2216.               </td>
  2217.             </tr>
  2218.             <tr>
  2219.               <td>
  2220.                 %RegExp%
  2221.               </td>
  2222.               <td>
  2223.                 `RegExp`
  2224.               </td>
  2225.               <td>
  2226.                 The `RegExp` constructor (<emu-xref href="#sec-regexp-constructor"></emu-xref>)
  2227.               </td>
  2228.             </tr>
  2229.             <tr>
  2230.               <td>
  2231.                 %RegExpPrototype%
  2232.               </td>
  2233.               <td>
  2234.                 `RegExp.prototype`
  2235.               </td>
  2236.               <td>
  2237.                 The initial value of the `prototype` data property of %RegExp%
  2238.               </td>
  2239.             </tr>
  2240.             <tr>
  2241.               <td>
  2242.                 %Set%
  2243.               </td>
  2244.               <td>
  2245.                 `Set`
  2246.               </td>
  2247.               <td>
  2248.                 The `Set` constructor (<emu-xref href="#sec-set-constructor"></emu-xref>)
  2249.               </td>
  2250.             </tr>
  2251.             <tr>
  2252.               <td>
  2253.                 %SetIteratorPrototype%
  2254.               </td>
  2255.               <td>
  2256.               </td>
  2257.               <td>
  2258.                 The prototype of Set iterator objects (<emu-xref href="#sec-set-iterator-objects"></emu-xref>)
  2259.               </td>
  2260.             </tr>
  2261.             <tr>
  2262.               <td>
  2263.                 %SetPrototype%
  2264.               </td>
  2265.               <td>
  2266.                 `Set.prototype`
  2267.               </td>
  2268.               <td>
  2269.                 The initial value of the `prototype` data property of %Set%
  2270.               </td>
  2271.             </tr>
  2272.             <tr>
  2273.               <td>
  2274.                 %String%
  2275.               </td>
  2276.               <td>
  2277.                 `String`
  2278.               </td>
  2279.               <td>
  2280.                 The `String` constructor (<emu-xref href="#sec-string-constructor"></emu-xref>)
  2281.               </td>
  2282.             </tr>
  2283.             <tr>
  2284.               <td>
  2285.                 %StringIteratorPrototype%
  2286.               </td>
  2287.               <td>
  2288.               </td>
  2289.               <td>
  2290.                 The prototype of String iterator objects (<emu-xref href="#sec-string-iterator-objects"></emu-xref>)
  2291.               </td>
  2292.             </tr>
  2293.             <tr>
  2294.               <td>
  2295.                 %StringPrototype%
  2296.               </td>
  2297.               <td>
  2298.                 `String.prototype`
  2299.               </td>
  2300.               <td>
  2301.                 The initial value of the `prototype` data property of %String%
  2302.               </td>
  2303.             </tr>
  2304.             <tr>
  2305.               <td>
  2306.                 %Symbol%
  2307.               </td>
  2308.               <td>
  2309.                 `Symbol`
  2310.               </td>
  2311.               <td>
  2312.                 The `Symbol` constructor (<emu-xref href="#sec-symbol-constructor"></emu-xref>)
  2313.               </td>
  2314.             </tr>
  2315.             <tr>
  2316.               <td>
  2317.                 %SymbolPrototype%
  2318.               </td>
  2319.               <td>
  2320.                 `Symbol.prototype`
  2321.               </td>
  2322.               <td>
  2323.                 The initial value of the `prototype` data property of %Symbol%. (<emu-xref href="#sec-properties-of-the-symbol-prototype-object"></emu-xref>)
  2324.               </td>
  2325.             </tr>
  2326.             <tr>
  2327.               <td>
  2328.                 %SyntaxError%
  2329.               </td>
  2330.               <td>
  2331.                 `SyntaxError`
  2332.               </td>
  2333.               <td>
  2334.                 The `SyntaxError` constructor (<emu-xref href="#sec-native-error-types-used-in-this-standard-syntaxerror"></emu-xref>)
  2335.               </td>
  2336.             </tr>
  2337.             <tr>
  2338.               <td>
  2339.                 %SyntaxErrorPrototype%
  2340.               </td>
  2341.               <td>
  2342.                 `SyntaxError.prototype`
  2343.               </td>
  2344.               <td>
  2345.                 The initial value of the `prototype` property of %SyntaxError%
  2346.               </td>
  2347.             </tr>
  2348.             <tr>
  2349.               <td>
  2350.                 %ThrowTypeError%
  2351.               </td>
  2352.               <td>
  2353.               </td>
  2354.               <td>
  2355.                 A function object that unconditionally throws a new instance of %TypeError%
  2356.               </td>
  2357.             </tr>
  2358.             <tr>
  2359.               <td>
  2360.                 %TypedArray%
  2361.               </td>
  2362.               <td>
  2363.               </td>
  2364.               <td>
  2365.                 The super class of all typed Array constructors (<emu-xref href="#sec-%typedarray%-intrinsic-object"></emu-xref>)
  2366.               </td>
  2367.             </tr>
  2368.             <tr>
  2369.               <td>
  2370.                 %TypedArrayPrototype%
  2371.               </td>
  2372.               <td>
  2373.               </td>
  2374.               <td>
  2375.                 The initial value of the `prototype` property of %TypedArray%
  2376.               </td>
  2377.             </tr>
  2378.             <tr>
  2379.               <td>
  2380.                 %TypeError%
  2381.               </td>
  2382.               <td>
  2383.                 `TypeError`
  2384.               </td>
  2385.               <td>
  2386.                 The `TypeError` constructor (<emu-xref href="#sec-native-error-types-used-in-this-standard-typeerror"></emu-xref>)
  2387.               </td>
  2388.             </tr>
  2389.             <tr>
  2390.               <td>
  2391.                 %TypeErrorPrototype%
  2392.               </td>
  2393.               <td>
  2394.                 `TypeError.prototype`
  2395.               </td>
  2396.               <td>
  2397.                 The initial value of the `prototype` property of %TypeError%
  2398.               </td>
  2399.             </tr>
  2400.             <tr>
  2401.               <td>
  2402.                 %Uint8Array%
  2403.               </td>
  2404.               <td>
  2405.                 `Uint8Array`
  2406.               </td>
  2407.               <td>
  2408.                 The `Uint8Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  2409.               </td>
  2410.             </tr>
  2411.             <tr>
  2412.               <td>
  2413.                 %Uint8ArrayPrototype%
  2414.               </td>
  2415.               <td>
  2416.                 `Uint8Array.prototype`
  2417.               </td>
  2418.               <td>
  2419.                 The initial value of the `prototype` data property of %Uint8Array%
  2420.               </td>
  2421.             </tr>
  2422.             <tr>
  2423.               <td>
  2424.                 %Uint8ClampedArray%
  2425.               </td>
  2426.               <td>
  2427.                 `Uint8ClampedArray`
  2428.               </td>
  2429.               <td>
  2430.                 The `Uint8ClampedArray` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  2431.               </td>
  2432.             </tr>
  2433.             <tr>
  2434.               <td>
  2435.                 %Uint8ClampedArrayPrototype%
  2436.               </td>
  2437.               <td>
  2438.                 `Uint8ClampedArray.prototype`
  2439.               </td>
  2440.               <td>
  2441.                 The initial value of the `prototype` data property of %Uint8ClampedArray%
  2442.               </td>
  2443.             </tr>
  2444.             <tr>
  2445.               <td>
  2446.                 %Uint16Array%
  2447.               </td>
  2448.               <td>
  2449.                 `Uint16Array`
  2450.               </td>
  2451.               <td>
  2452.                 The `Uint16Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  2453.               </td>
  2454.             </tr>
  2455.             <tr>
  2456.               <td>
  2457.                 %Uint16ArrayPrototype%
  2458.               </td>
  2459.               <td>
  2460.                 `Uint16Array.prototype`
  2461.               </td>
  2462.               <td>
  2463.                 The initial value of the `prototype` data property of %Uint16Array%
  2464.               </td>
  2465.             </tr>
  2466.             <tr>
  2467.               <td>
  2468.                 %Uint32Array%
  2469.               </td>
  2470.               <td>
  2471.                 `Uint32Array`
  2472.               </td>
  2473.               <td>
  2474.                 The `Uint32Array` constructor (<emu-xref href="#sec-typedarray-objects"></emu-xref>)
  2475.               </td>
  2476.             </tr>
  2477.             <tr>
  2478.               <td>
  2479.                 %Uint32ArrayPrototype%
  2480.               </td>
  2481.               <td>
  2482.                 `Uint32Array.prototype`
  2483.               </td>
  2484.               <td>
  2485.                 The initial value of the `prototype` data property of %Uint32Array%
  2486.               </td>
  2487.             </tr>
  2488.             <tr>
  2489.               <td>
  2490.                 %URIError%
  2491.               </td>
  2492.               <td>
  2493.                 `URIError`
  2494.               </td>
  2495.               <td>
  2496.                 The `URIError` constructor (<emu-xref href="#sec-native-error-types-used-in-this-standard-urierror"></emu-xref>)
  2497.               </td>
  2498.             </tr>
  2499.             <tr>
  2500.               <td>
  2501.                 %URIErrorPrototype%
  2502.               </td>
  2503.               <td>
  2504.                 `URIError.prototype`
  2505.               </td>
  2506.               <td>
  2507.                 The initial value of the `prototype` property of %URIError%
  2508.               </td>
  2509.             </tr>
  2510.             <tr>
  2511.               <td>
  2512.                 %WeakMap%
  2513.               </td>
  2514.               <td>
  2515.                 `WeakMap`
  2516.               </td>
  2517.               <td>
  2518.                 The `WeakMap` constructor (<emu-xref href="#sec-weakmap-constructor"></emu-xref>)
  2519.               </td>
  2520.             </tr>
  2521.             <tr>
  2522.               <td>
  2523.                 %WeakMapPrototype%
  2524.               </td>
  2525.               <td>
  2526.                 `WeakMap.prototype`
  2527.               </td>
  2528.               <td>
  2529.                 The initial value of the `prototype` data property of %WeakMap%
  2530.               </td>
  2531.             </tr>
  2532.             <tr>
  2533.               <td>
  2534.                 %WeakSet%
  2535.               </td>
  2536.               <td>
  2537.                 `WeakSet`
  2538.               </td>
  2539.               <td>
  2540.                 The `WeakSet` constructor (<emu-xref href="#sec-weakset-constructor"></emu-xref>)
  2541.               </td>
  2542.             </tr>
  2543.             <tr>
  2544.               <td>
  2545.                 %WeakSetPrototype%
  2546.               </td>
  2547.               <td>
  2548.                 `WeakSet.prototype`
  2549.               </td>
  2550.               <td>
  2551.                 The initial value of the `prototype` data property of %WeakSet%
  2552.               </td>
  2553.             </tr>
  2554.             </tbody>
  2555.           </table>
  2556.         </emu-table>
  2557.       </emu-clause>
  2558.     </emu-clause>
  2559.   </emu-clause>
  2561.   <!-- es6num="6.2" -->
  2562.   <emu-clause id="sec-ecmascript-specification-types">
  2563.     <h1>ECMAScript Specification Types</h1>
  2564.     <p>A specification type corresponds to meta-values that are used within algorithms to describe the semantics of ECMAScript language constructs and ECMAScript language types. The specification types are Reference, List, Completion, Property Descriptor, Lexical Environment, Environment Record, and Data Block. Specification type values are specification artefacts that do not necessarily correspond to any specific entity within an ECMAScript implementation. Specification type values may be used to describe intermediate results of ECMAScript expression evaluation but such values cannot be stored as properties of objects or values of ECMAScript language variables.</p>
  2566.     <!-- es6num="6.2.1" -->
  2567.     <emu-clause id="sec-list-and-record-specification-type">
  2568.       <h1>The List and Record Specification Types</h1>
  2569.       <p>The <dfn>List</dfn> type is used to explain the evaluation of argument lists (see <emu-xref href="#sec-argument-lists"></emu-xref>) in `new` expressions, in function calls, and in other algorithms where a simple ordered list of values is needed. Values of the List type are simply ordered sequences of list elements containing the individual values. These sequences may be of any length. The elements of a list may be randomly accessed using 0-origin indices. For notational convenience an array-like syntax can be used to access List elements. For example, _arguments_[2] is shorthand for saying the 3<sup>rd</sup> element of the List _arguments_.</p>
  2570.       <p>For notational convenience within this specification, a literal syntax can be used to express a new List value. For example, &laquo; 1, 2 &raquo; defines a List value that has two elements each of which is initialized to a specific value. A new empty List can be expressed as &laquo; &raquo;.</p>
  2571.       <p>The <dfn>Record</dfn> type is used to describe data aggregations within the algorithms of this specification. A Record type value consists of one or more named fields. The value of each field is either an ECMAScript value or an abstract value represented by a name associated with the Record type. Field names are always enclosed in double brackets, for example [[Value]].</p>
  2572.       <p>For notational convenience within this specification, an object literal-like syntax can be used to express a Record value. For example, {[[Field1]]: 42, [[Field2]]: *false*, [[Field3]]: ~empty~} defines a Record value that has three fields, each of which is initialized to a specific value. Field name order is not significant. Any fields that are not explicitly listed are considered to be absent.</p>
  2573.       <p>In specification text and algorithms, dot notation may be used to refer to a specific field of a Record value. For example, if R is the record shown in the previous paragraph then R.[[Field2]] is shorthand for &ldquo;the field of R named [[Field2]]&rdquo;.</p>
  2574.       <p>Schema for commonly used Record field combinations may be named, and that name may be used as a prefix to a literal Record value to identify the specific kind of aggregations that is being described. For example: PropertyDescriptor{[[Value]]: 42, [[Writable]]: *false*, [[Configurable]]: *true*}.</p>
  2575.     </emu-clause>
  2577.     <!-- es6num="6.2.2" -->
  2578.     <emu-clause id="sec-completion-record-specification-type" aoid="Completion">
  2579.       <h1>The Completion Record Specification Type</h1>
  2580.       <p>The Completion type is a Record used to explain the runtime propagation of values and control flow such as the behaviour of statements (`break`, `continue`, `return` and `throw`) that perform nonlocal transfers of control.</p>
  2581.       <p>Values of the Completion type are Record values whose fields are defined as by <emu-xref href="#table-8"></emu-xref>. Such values are referred to as <dfn>Completion Record</dfn>s.</p>
  2582.       <emu-table id="table-8" caption="Completion Record Fields">
  2583.         <table>
  2584.           <tbody>
  2585.           <tr>
  2586.             <th>
  2587.               Field
  2588.             </th>
  2589.             <th>
  2590.               Value
  2591.             </th>
  2592.             <th>
  2593.               Meaning
  2594.             </th>
  2595.           </tr>
  2596.           <tr>
  2597.             <td>
  2598.               [[Type]]
  2599.             </td>
  2600.             <td>
  2601.               One of ~normal~, ~break~, ~continue~, ~return~, or ~throw~
  2602.             </td>
  2603.             <td>
  2604.               The type of completion that occurred.
  2605.             </td>
  2606.           </tr>
  2607.           <tr>
  2608.             <td>
  2609.               [[Value]]
  2610.             </td>
  2611.             <td>
  2612.               any ECMAScript language value or ~empty~
  2613.             </td>
  2614.             <td>
  2615.               The value that was produced.
  2616.             </td>
  2617.           </tr>
  2618.           <tr>
  2619.             <td>
  2620.               [[Target]]
  2621.             </td>
  2622.             <td>
  2623.               any ECMAScript string or ~empty~
  2624.             </td>
  2625.             <td>
  2626.               The target label for directed control transfers.
  2627.             </td>
  2628.           </tr>
  2629.           </tbody>
  2630.         </table>
  2631.       </emu-table>
  2632.       <p>The term &ldquo;<dfn>abrupt completion</dfn>&rdquo; refers to any completion with a [[Type]] value other than ~normal~.</p>
  2634.       <!-- es6num="" -->
  2635.       <emu-clause id="sec-normalcompletion" aoid="NormalCompletion">
  2636.         <h1>NormalCompletion</h1>
  2637.         <p>The abstract operation NormalCompletion with a single _argument_, such as:</p>
  2638.         <emu-alg>
  2639.           1. Return NormalCompletion(_argument_).
  2640.         </emu-alg>
  2641.         <p>Is a shorthand that is defined as follows:</p>
  2642.         <emu-alg>
  2643.           1. Return Completion{[[Type]]: ~normal~, [[Value]]: _argument_, [[Target]]: ~empty~}.
  2644.         </emu-alg>
  2645.       </emu-clause>
  2647.       <!-- es6num="" -->
  2648.       <emu-clause id="sec-implicit-completion-values">
  2649.         <h1>Implicit Completion Values</h1>
  2650.         <p>The algorithms of this specification often implicitly return Completion Records whose [[Type]] is ~normal~. Unless it is otherwise obvious from the context, an algorithm statement that returns a value that is not a Completion Record, such as:</p>
  2651.         <emu-alg>
  2652.           1. Return `"Infinity"`.
  2653.         </emu-alg>
  2654.         <p>means the same thing as:</p>
  2655.         <emu-alg>
  2656.           1. Return NormalCompletion(`"Infinity"`).
  2657.         </emu-alg>
  2658.         <p>However, if the value expression of a &ldquo;return&rdquo; statement is a Completion Record construction literal, the resulting Completion Record is returned. If the value expression is a call to an abstract operation, the &ldquo;return&rdquo; statement simply returns the Completion Record produced by the abstract operation.</p>
  2659.         <p>The abstract operation Completion(_completionRecord_) is used to emphasize that a previously computed Completion Record is being returned. The Completion abstract operation takes a single argument, _completionRecord_, and performs the following steps:</p>
  2660.         <emu-alg>
  2661.           1. Assert: _completionRecord_ is a Completion Record.
  2662.           1. Return _completionRecord_ as the Completion Record of this abstract operation.
  2663.         </emu-alg>
  2664.         <p>A &ldquo;return&rdquo; statement without a value in an algorithm step means the same thing as:</p>
  2665.         <emu-alg>
  2666.           1. Return NormalCompletion(*undefined*).
  2667.         </emu-alg>
  2668.         <p>Any reference to a Completion Record value that is in a context that does not explicitly require a complete Completion Record value is equivalent to an explicit reference to the [[Value]] field of the Completion Record value unless the Completion Record is an abrupt completion.</p>
  2669.       </emu-clause>
  2671.       <!-- es6num="" -->
  2672.       <emu-clause id="sec-throw-an-exception">
  2673.         <h1>Throw an Exception</h1>
  2674.         <p>Algorithms steps that say to throw an exception, such as</p>
  2675.         <emu-alg>
  2676.           1. Throw a *TypeError* exception.
  2677.         </emu-alg>
  2678.         <p>mean the same things as:</p>
  2679.         <emu-alg>
  2680.           1. Return Completion{[[Type]]: ~throw~, [[Value]]: a newly created *TypeError* object, [[Target]]: ~empty~}.
  2681.         </emu-alg>
  2682.       </emu-clause>