The List type is used to explain the evaluation of argument lists (see ) 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 3rd element of the List _arguments_.
For notational convenience within this specification, a literal syntax can be used to express a new List value. For example, « 1, 2 » 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 « ».
-
The Record 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]].
+
The Record 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]].
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.
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 “the field of R named [[field2]]”.
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*}.
@@ -5935,7 +5935,8 @@
SetDefaultGlobalBindings ( _realmRec_ )
Execution Contexts
-
An execution context is a specification device that is used to track the runtime evaluation of code by an ECMAScript implementation. At any point in time, there is at most one execution context that is actually executing code. This is known as the running execution context. A stack is used to track execution contexts. The running execution context is always the top element of this stack. A new execution context is created whenever control is transferred from the executable code associated with the currently running execution context to executable code that is not associated with that execution context. The newly created execution context is pushed onto the stack and becomes the running execution context.
+
An execution context is a specification device that is used to track the runtime evaluation of code by an ECMAScript implementation. At any point in time, there is at most one execution context that is actually executing code. This is known as the running execution context.
+
An execution context stack is used to track execution contexts. The running execution context is always the top element of this stack. A new execution context is created whenever control is transferred from the executable code associated with the currently running execution context to executable code that is not associated with that execution context. The newly created execution context is pushed onto the stack and becomes the running execution context.
An execution context contains whatever implementation specific state is necessary to track the execution progress of its associated code. Each execution context has at least the state components listed in .
@@ -5972,11 +5973,19 @@
Execution Contexts
The Realm from which associated code accesses ECMAScript resources.
+
+
+ ScriptOrModule
+
+
+ The Module Record or Script Record from which associated code originates. If there is no originating script or module, as is the case for the original execution context created in InitializeHostDefinedRealm, the value is *null*.
+
+
Evaluation of code by the running execution context may be suspended at various points defined within this specification. Once the running execution context has been suspended a different execution context may become the running execution context and commence evaluating its code. At some later time a suspended execution context may again become the running execution context and continue evaluating its code at the point where it had previously been suspended. Transition of the running execution context status among execution contexts usually occurs in stack-like last-in/first-out manner. However, some ECMAScript features require non-LIFO transitions of the running execution context.
-
The value of the Realm component of the running execution context is also called the current Realm. The value of the Function component of the running execution context is also called the active function object.
+
The value of the Realm component of the running execution context is also called the current Realm. The value of the Function component of the running execution context is also called the active function object.
Execution contexts for ECMAScript code have the additional state components listed in .
@@ -6035,6 +6044,20 @@
Execution Contexts
In most situations only the running execution context (the top of the execution context stack) is directly manipulated by algorithms within this specification. Hence when the terms “LexicalEnvironment”, and “VariableEnvironment” are used without qualification they are in reference to those components of the running execution context.
An execution context is purely a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation. It is impossible for ECMAScript code to directly access or observe an execution context.
+
+
GetActiveScriptOrModule ()
+
The GetActiveScriptOrModule abstract operation is used to determine the running script or module, based on the active function object. GetActiveScriptOrModule performs the following steps:
+
+
+ 1. If the execution context stack is empty, return *null*.
+ 1. Let _ec_ be the topmost execution context on the execution context stack whose Function component's [[ScriptOrModule]] component is not *null*.
+ 1. If such an execution context exists, return _ec_'s Function component's [[ScriptOrModule]] slot's value.
+ 1. Otherwise, let _ec_ be the running execution context.
+ 1. Assert: _ec_'s ScriptOrModule component is not *null*.
+ 1. Return _ec_'s ScriptOrModule component.
+
+
+
ResolveBinding ( _name_, [_env_] )
@@ -6154,6 +6177,17 @@
Jobs and Job Queues
The Realm for the initial execution context when this PendingJob is initiated.
+
+
+ [[ScriptOrModule]]
+
+
+ A Script Record or Module Record
+
+
+ The script or module for the initial execution context when this PendingJob is initiated.
+
+
[[HostDefined]]
@@ -6216,7 +6250,8 @@
EnqueueJob (_queueName_, _job_, _arguments_)
1. Assert: _arguments_ is a List that has the same number of elements as the number of parameters required by _job_.
1. Let _callerContext_ be the running execution context.
1. Let _callerRealm_ be _callerContext_'s Realm.
- 1. Let _pending_ be PendingJob{ [[Job]]: _job_, [[Arguments]]: _arguments_, [[Realm]]: _callerRealm_, [[HostDefined]]: *undefined* }.
+ 1. Let _callerScriptOrModule_ be _callerContext_'s ScriptOrModule.
+ 1. Let _pending_ be PendingJob{ [[Job]]: _job_, [[Arguments]]: _arguments_, [[Realm]]: _callerRealm_, [[ScriptOrModule]]: _callerScriptOrModule_, [[HostDefined]]: *undefined* }.
1. Perform any implementation or host environment defined processing of _pending_. This may include modifying the [[HostDefined]] field or any other field of _pending_.
1. Add _pending_ at the back of the Job Queue named by _queueName_.
1. Return NormalCompletion(~empty~).
@@ -6236,7 +6271,7 @@
NextJob result
Job abstract operations must not contain a Return step or a ReturnIfAbrupt step. The NextJob _result_ operation is equivalent to the following steps:
- 1. If _result_ is an abrupt completion, perform implementation defined unhandled exception processing.
+ 1. If _result_ is an abrupt completion, perform HostReportErrors(« _result_.[[value]] »).
1. Suspend the running execution context and remove it from the execution context stack.
1. Assert: The execution context stack is now empty.
1. Let _nextQueue_ be a non-empty Job Queue chosen in an implementation defined manner. If all Job Queues are empty, the result is implementation defined.
@@ -6244,6 +6279,7 @@
NextJob result
1. Let _newContext_ be a new execution context.
1. Set _newContext_'s Function to *null*.
1. Set _newContext_'s Realm to _nextPending_.[[Realm]].
+ 1. Set _newContext_'s ScriptOrModule to _nextPending_.[[ScriptOrModule]].
1. Push _newContext_ onto the execution context stack; _newContext_ is now the running execution context.
1. Perform any implementation or host environment defined job initialization using _nextPending_.
1. Perform the abstract operation named by _nextPending_.[[Job]] using the elements of _nextPending_.[[Arguments]] as its arguments.
@@ -6260,17 +6296,18 @@
InitializeHostDefinedRealm( )
1. Let _newContext_ be a new execution context.
1. Set the Function of _newContext_ to *null*.
1. Set the Realm of _newContext_ to _realm_.
+ 1. Set the ScriptOrModule of _newContext_ to *null*.
1. Push _newContext_ onto the execution context stack; _newContext_ is now the running execution context.
1. If the host requires use of an exotic object to serve as _realm_'s global object, let _global_ be such an object created in an implementation defined manner. Otherwise, let _global_ be *undefined*, indicating that an ordinary object should be created as the global object.
1. If the host requires that the `this` binding in _realm_'s global scope return an object other than the global object, let _thisValue_ be such an object created in an implementation defined manner. Otherwise, let _thisValue_ be *undefined*, indicating that _realm_'s global `this` binding should be the global object.
1. Perform SetRealmGlobalObject(_realm_, _global_, _thisValue_).
1. Let _globalObj_ be ? SetDefaultGlobalBindings(_realm_).
1. Create any implementation defined global object properties on _globalObj_.
- 1. In an implementation dependent manner, obtain the ECMAScript source texts (see clause ) for zero or more ECMAScript scripts and/or ECMAScript modules. For each such _sourceText_ do,
+ 1. In an implementation dependent manner, obtain the ECMAScript source texts (see clause ) and any associated host-defined values for zero or more ECMAScript scripts and/or ECMAScript modules. For each such _sourceText_ and _hostDefined_,
1. If _sourceText_ is the source code of a script, then
- 1. Perform EnqueueJob(`"ScriptJobs"`, ScriptEvaluationJob, « _sourceText_ »).
+ 1. Perform EnqueueJob(`"ScriptJobs"`, ScriptEvaluationJob, « _sourceText_, _hostDefined_ »).
1. Else _sourceText_ is the source code of a module,
- 1. Perform EnqueueJob(`"ScriptJobs"`, TopLevelModuleEvaluationJob, « _sourceText_ »).
+ 1. Perform EnqueueJob(`"ScriptJobs"`, TopLevelModuleEvaluationJob, « _sourceText_, _hostDefined_ »).
1. NextJob NormalCompletion(*undefined*).
@@ -6716,6 +6753,17 @@
ECMAScript Function Objects
The Code Realm in which the function was created and which provides any intrinsic objects that are accessed when evaluating the function.
+
+
+ [[ScriptOrModule]]
+
+
+ Script Record or Module Record
+
+
+ The script or module in which the function was created.
+
+
[[ThisMode]]
@@ -6786,6 +6834,7 @@
PrepareForOrdinaryCall( _F_, _newTarget_ )
1. Set the Function of _calleeContext_ to _F_.
1. Let _calleeRealm_ be the value of _F_'s [[Realm]] internal slot.
1. Set the Realm of _calleeContext_ to _calleeRealm_.
+ 1. Set the ScriptOrModule of _calleeContext_ to the value of _F_'s [[ScriptOrModule]] internal slot.
1. Let _localEnv_ be NewFunctionEnvironment(_F_, _newTarget_).
1. Set the LexicalEnvironment of _calleeContext_ to _localEnv_.
1. Set the VariableEnvironment of _calleeContext_ to _localEnv_.
@@ -6895,6 +6944,7 @@
1. Set the [[Environment]] internal slot of _F_ to the value of _Scope_.
1. Set the [[FormalParameters]] internal slot of _F_ to _ParameterList_ .
1. Set the [[ECMAScriptCode]] internal slot of _F_ to _Body_.
+ 1. Set the [[ScriptOrModule]] internal slot of _F_ to GetActiveScriptOrModule().
1. If _kind_ is ~Arrow~, set the [[ThisMode]] internal slot of _F_ to ~lexical~.
1. Else if _Strict_ is *true*, set the [[ThisMode]] internal slot of _F_ to ~strict~.
1. Else set the [[ThisMode]] internal slot of _F_ to ~global~.
@@ -7145,7 +7195,7 @@
The built-in function objects defined in this specification may be implemented as either ECMAScript function objects () whose behaviour is provided using ECMAScript code or as implementation provided exotic function objects whose behaviour is provided in some other manner. In either case, the effect of calling such functions must conform to their specifications. An implementation may also provide additional built-in function objects that are not defined in this specification.
-
If a built-in function object is implemented as an exotic object it must have the ordinary object behaviour specified in . All such exotic function objects also have [[Prototype]], [[Extensible]], and [[Realm]] internal slots.
+
If a built-in function object is implemented as an exotic object it must have the ordinary object behaviour specified in . All such exotic function objects also have [[Prototype]], [[Extensible]], [[Realm]], and [[ScriptOrModule]] internal slots.
Unless otherwise specified every built-in function object has the %FunctionPrototype% object () as the initial value of its [[Prototype]] internal slot.
The behaviour specified for each built-in function via algorithm steps or other means is the specification of the function body behaviour for both [[Call]] and [[Construct]] invocations of the function. However, [[Construct]] invocation is not supported by all built-in functions. For each built-in function, when invoked with [[Call]], the [[Call]] _thisArgument_ provides the *this* value, the [[Call]] _argumentsList_ provides the named parameters, and the NewTarget value is *undefined*. When invoked with [[Construct]], the *this* value is uninitialized, the [[Construct]] _argumentsList_ provides the named parameters, and the [[Construct]] _newTarget_ parameter provides the NewTarget value. If the built-in function is implemented as an ECMAScript function object then this specified behaviour must be implemented by the ECMAScript code that is the body of the function. Built-in functions that are ECMAScript function objects must be strict mode functions. If a built-in constructor has any [[Call]] behaviour other than throwing a *TypeError* exception, an ECMAScript implementation of the function must be done in a manner that does not cause the function's [[FunctionKind]] internal slot to have the value `"classConstructor"`.
Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function. When a built-in constructor is called as part of a `new` expression the _argumentsList_ parameter of the invoked [[Construct]] internal method provides the values for the built-in constructor's named parameters.
@@ -7163,6 +7213,7 @@
[[Call]] ( _thisArgument_, _argumentsList_)
1. Set the Function of _calleeContext_ to _F_.
1. Let _calleeRealm_ be the value of _F_'s [[Realm]] internal slot.
1. Set the Realm of _calleeContext_ to _calleeRealm_.
+ 1. Set the ScriptOrModule of _calleeContext_ to the value of _F_'s [[ScriptOrModule]] internal slot.
1. Perform any necessary implementation defined initialization of _calleeContext_.
1. Push _calleeContext_ onto the execution context stack; _calleeContext_ is now the running execution context.
1. Let _result_ be the Completion Record that is the result of evaluating _F_ in an implementation defined manner that conforms to the specification of _F_. _thisArgument_ is the *this* value, _argumentsList_ provides the named parameters, and the NewTarget value is *undefined*.
@@ -7177,9 +7228,9 @@
[[Call]] ( _thisArgument_, _argumentsList_)
[[Construct]] (_argumentsList_, _newTarget_)
-
The [[Construct]] internal method for built-in function object _F_ is called with parameters _argumentsList_ and _newTarget_. The steps performed are the same as [[Call]] (see ) except that step 9 is replaced by:
+
The [[Construct]] internal method for built-in function object _F_ is called with parameters _argumentsList_ and _newTarget_. The steps performed are the same as [[Call]] (see ) except that step 10 is replaced by:
- 9. Let _result_ be the Completion Record that is the result of evaluating _F_ in an implementation defined manner that conforms to the specification of _F_. The *this* value is uninitialized, _argumentsList_ provides the named parameters, and _newTarget_ provides the NewTarget value.
+ 10. Let _result_ be the Completion Record that is the result of evaluating _F_ in an implementation defined manner that conforms to the specification of _F_. The *this* value is uninitialized, _argumentsList_ provides the named parameters, and _newTarget_ provides the NewTarget value.
@@ -7194,6 +7245,7 @@
Each built-in function defined in this specification is created as if by calling the CreateBuiltinFunction abstract operation, unless otherwise specified.
A Script Record encapsulates information about a script being evaluated. Each script record contains the fields listed in .
+
+
+
+
+
+
+ Field Name
+
+
+ Value Type
+
+
+ Meaning
+
+
+
+
+
+
+ [[Realm]]
+
+
+ Realm Record | *undefined*
+
+
+ The Realm within which this script was created. *undefined* if not yet assigned.
+
+
+
+
+ [[Environment]]
+
+
+ Lexical Environment | *undefined*
+
+
+ The Lexical Environment containing the top level bindings for this script. This field is set when the script is instantiated.
+
+
+
+
+ [[ECMAScriptCode]]
+
+
+ a parse result
+
+
+ The result of parsing the source text of this module using |Script| as the goal symbol.
+
+
+
+
+ [[HostDefined]]
+
+
+ Any, default value is *undefined*.
+
+
+ Field reserved for use by host environments that need to associate additional information with a script.
+
+
+
+
+
+
+
+
+
ParseScript ( _sourceText_, _hostDefined_ )
+
+
The abstract operation ParseScript with arguments _sourceText_ and _hostDefined_ creates a Script Record based upon the result of parsing _sourceText_ as a |Script|. ParseScript performs the following steps:
+
+
+ 1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
+ 1. Parse _sourceText_ using |Script| as the goal symbol and analyze the parse result for any Early Error conditions. If the parse was successful and no early errors were found, let _body_ be the resulting parse tree. Otherwise, let _body_ be a List of one or more *SyntaxError* or *ReferenceError* objects representing the parsing errors and/or early errors. Parsing and early error detection may be interweaved in an implementation dependent manner. If more than one parsing error or early error is present, the number and ordering of error objects in the list is implementation dependent, but at least one must be present.
+ 1. If _body_ is a List of errors, then return _body_.
+ 1. Let _realm_ be the running execution context's Realm.
+ 1. Return Script Record {[[Realm]]: _realm_, [[Environment]]: *undefined*, [[ECMAScriptCode]]: _body_, [[HostDefined]]: _hostDefined_}.
+
+
+
An implementation may parse script source text and analyze it for Early Error conditions prior to evaluation of ParseScript for that script source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseScript upon that source text.
+
+
+
-
-
Runtime Semantics: ScriptEvaluation
-
With argument _realm_.
- Script : ScriptBody?
+
+
ScriptEvaluation ( _scriptRecord_ )
+
- 1. If |ScriptBody| is not present, return NormalCompletion(~empty~).
- 1. Let _globalEnv_ be _realm_.[[globalEnv]].
+ 1. Let _globalEnv_ be _scriptRecord_.[[Realm]].[[globalEnv]].
1. Let _scriptCxt_ be a new ECMAScript code execution context.
1. Set the Function of _scriptCxt_ to *null*.
- 1. Set the Realm of _scriptCxt_ to _realm_.
+ 1. Set the Realm of _scriptCxt_ to _scriptRecord_.[[Realm]].
+ 1. Set the ScriptOrModule of _scriptCxt_ to _scriptRecord_.
1. Set the VariableEnvironment of _scriptCxt_ to _globalEnv_.
1. Set the LexicalEnvironment of _scriptCxt_ to _globalEnv_.
1. Suspend the currently running execution context.
@@ -19567,22 +19713,17 @@
The job ScriptEvaluationJob with parameters _sourceText_ and _hostDefined_ parses, validates, and evaluates _sourceText_ as a |Script|.
1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
- 1. Parse _sourceText_ using |Script| as the goal symbol and analyze the parse result for any Early Error conditions. If the parse was successful and no early errors were found, let _code_ be the resulting parse tree. Otherwise, let _code_ be an indication of one or more parsing errors and/or early errors. Parsing and early error detection may be interweaved in an implementation dependent manner. If more than one parse or early error is present, the number and ordering of reported errors is implementation dependent but at least one error must be reported.
- 1. If _code_ is an error indication, then
- 1. Report or log the error(s) in an implementation dependent manner.
- 1. Let _status_ be NormalCompletion(*undefined*).
- 1. Else,
- 1. Let _realm_ be the running execution context's Realm.
- 1. Let _status_ be the result of ScriptEvaluation of _code_ with argument _realm_.
+ 1. Let _s_ be ParseScript(_sourceText_, _hostDefined_).
+ 1. If _s_ is a List of errors, then
+ 1. Perform HostReportErrors(_s_).
+ 1. NextJob NormalCompletion(*undefined*).
+ 1. Let _status_ be ScriptEvaluation(_s_).
1. NextJob Completion(_status_).
-
-
An implementation may parse a _sourceText_ as a |Script| and analyze it for Early Error conditions prior to the execution of the ScriptEvaluationJob for that _sourceText_. However, the reporting of any errors must be deferred until the ScriptEvaluationJob is actually executed.
-
@@ -19956,7 +20097,7 @@
Abstract Module Records
Module Record defines the fields listed in . All Module Definition subclasses include at least those fields. Module Record also defines the abstract method list in . All Module definition subclasses must provide concrete implementations of these abstract methods.
-
+
Field Name
@@ -19968,6 +20109,8 @@
Abstract Module Records
Meaning
+
+
[[Realm]]
@@ -20012,6 +20155,17 @@
Abstract Module Records
Initially *false*, *true* if evaluation of this module has started. Remains *true* when evaluation completes, even if it is an abrupt completion.
+
+
+ [[HostDefined]]
+
+
+ Any, default value is *undefined*.
+
+
+ Field reserved for use by host environments that need to associate additional information with a module.
+
+
@@ -20535,13 +20689,12 @@
Source Text Module Records
-
Runtime Semantics: ParseModule ( _sourceText_ )
-
The abstract operation ParseModule with argument _sourceText_ creates a Source Text Module Record based upon the result of parsing _sourceText_ as a |Module|. ParseModule performs the following steps:
+
ParseModule ( _sourceText_, _hostDefined_ )
+
The abstract operation ParseModule with arguments _sourceText_ and _hostDefined_ creates a Source Text Module Record based upon the result of parsing _sourceText_ as a |Module|. ParseModule performs the following steps:
1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
- 1. Parse _sourceText_ using |Module| as the goal symbol and analyze the parse result for any Early Error conditions. If the parse was successful and no early errors were found, let _body_ be the resulting parse tree. Otherwise, let _body_ be an indication of one or more parsing errors and/or early errors. Parsing and early error detection may be interweaved in an implementation dependent manner. If more than one parse or early error is present, the number and ordering of reported errors is implementation dependent but at least one error must be reported.
- 1. If _body_ is an abrupt completion or error indication, then
- 1. Throw a *SyntaxError* exception.
+ 1. Parse _sourceText_ using |Module| as the goal symbol and analyze the parse result for any Early Error conditions. If the parse was successful and no early errors were found, let _body_ be the resulting parse tree. Otherwise, let _body_ be a List of one or more *SyntaxError* or *ReferenceError* objects representing the parsing errors and/or early errors. Parsing and early error detection may be interweaved in an implementation dependent manner. If more than one parsing error or early error is present, the number and ordering of error objects in the list is implementation dependent, but at least one must be present.
+ 1. If _body_ is a List of errors, then return _body_.
1. Let _requestedModules_ be the ModuleRequests of _body_.
1. Let _importEntries_ be ImportEntries of _body_.
1. Let _importedBoundNames_ be ImportedLocalNames(_importEntries_).
@@ -20564,7 +20717,8 @@
Runtime Semantics: ParseModule ( _sourceText_ )
1. Append _ee_ to _starExportEntries_.
1. Else,
1. Append _ee_ to _indirectExportEntries_.
- 1. Return Source Text Module Record {[[Realm]]: *undefined*, [[Environment]]: *undefined*, [[Namespace]]: *undefined*, [[Evaluated]]: *false*, [[ECMAScriptCode]]: _body_, [[RequestedModules]]: _requestedModules_, [[ImportEntries]]: _importEntries_, [[LocalExportEntries]]: _localExportEntries_, [[StarExportEntries]]: _starExportEntries_, [[IndirectExportEntries]]: _indirectExportEntries_}.
+ 1. Let _realm_ be the running execution context's Realm.
+ 1. Return Source Text Module Record {[[Realm]]: _realm_, [[Environment]]: *undefined*, [[HostDefined]]: _hostDefined_, [[Namespace]]: *undefined*, [[Evaluated]]: *false*, [[ECMAScriptCode]]: _body_, [[RequestedModules]]: _requestedModules_, [[ImportEntries]]: _importEntries_, [[LocalExportEntries]]: _localExportEntries_, [[StarExportEntries]]: _starExportEntries_, [[IndirectExportEntries]]: _indirectExportEntries_}.
An implementation may parse module source text and analyze it for Early Error conditions prior to the evaluation of ParseModule for that module source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that source text.
@@ -20719,6 +20873,7 @@
ModuleEvaluation() Concrete Method
1. Let _moduleCxt_ be a new ECMAScript code execution context.
1. Set the Function of _moduleCxt_ to *null*.
1. Set the Realm of _moduleCxt_ to _module_.[[Realm]].
+ 1. Set the ScriptOrModule of _moduleCxt_ to _module_.
1. Assert: _module_ has been linked and declarations in its module environment have been instantiated.
1. Set the VariableEnvironment of _moduleCxt_ to _module_.[[Environment]].
1. Set the LexicalEnvironment of _moduleCxt_ to _module_.[[Environment]].
@@ -20772,16 +20927,14 @@
A TopLevelModuleEvaluationJob with parameters _sourceText_ and _hostDefined_ is a job that parses, validates, and evaluates _sourceText_ as a |Module|.
1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
- 1. Let _realm_ be the running execution context's Realm.
- 1. Let _m_ be ParseModule(_sourceText_).
- 1. If _m_ is an abrupt completion or any other implementation defined error indication, then
- 1. Report or log the error(s) in an implementation dependent manner.
+ 1. Let _m_ be ParseModule(_sourceText_, _hostDefined_).
+ 1. If _m_ is a List of errors, then
+ 1. Perform HostReportErrors(_m_).
1. NextJob NormalCompletion(*undefined*).
- 1. Set _m_.[[Realm]] to _realm_.
1. Let _status_ be _m_.ModuleDeclarationInstantiation().
1. If _status_ is not an abrupt completion, then
1. Assert: all dependencies of _m_ have been transitively resolved and _m_ is ready for evaluation.
@@ -21444,7 +21597,7 @@
Runtime Semantics: Evaluation
Error Handling and Language Extensions
-
An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. An early error is an error that can be detected and reported prior to the evaluation of any construct in the |Script| containing the error. The presence of an early error prevents the evaluation of the construct. An implementation must report early errors in a |Script| as part of the ScriptEvaluationJob for that |Script|. Early errors in a |Module| are reported at the point when the |Module| would be evaluated and the |Module| is never initialized. Early errors in eval code are reported at the time `eval` is called and prevent evaluation of the eval code. All errors that are not early errors are runtime errors.
+
An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. An early error is an error that can be detected and reported prior to the evaluation of any construct in the |Script| containing the error. The presence of an early error prevents the evaluation of the construct. An implementation must report early errors in a |Script| as part of parsing that |Script| in ParseScript. Early errors in a |Module| are reported at the point when the |Module| would be evaluated and the |Module| is never initialized. Early errors in eval code are reported at the time `eval` is called and prevent evaluation of the eval code. All errors that are not early errors are runtime errors.
An implementation must report as an early error any occurrence of a condition that is listed in a “Static Semantics: Early Errors” subclause of this specification.
An implementation shall not treat other kinds of errors as early errors even if the compiler can prove that a construct cannot execute without error under any circumstances. An implementation may issue an early warning in such a case, but it should not report the error until the relevant construct is actually executed.
An implementation shall report all errors as specified, except for the following:
@@ -21458,6 +21611,18 @@
Error Handling and Language Extensions
An implementation may define behaviour other than throwing *RangeError* for `toFixed`, `toExponential`, and `toPrecision` when the _fractionDigits_ or _precision_ argument is outside the specified range.
+
+
HostReportErrors( _errorList_ )
+
+
HostReportErrors is an implementation-defined abstract operation that allows host environments to report parsing errors, early errors, and runtime errors.
+
+
An implementation of HostReportErrors must complete normally in all cases. The default implementation of HostReportErrors is to do nothing.
+
+
+ _errorList_ will be a List of JavaScript values. If the errors are parsing errors or early errors, these will always be *SyntaxError* or *ReferenceError* objects. Runtime errors, however, can be any ECMAScript value.
+
+
+
Forbidden Extensions
@@ -21591,6 +21756,7 @@
Runtime Semantics: PerformEval( _x_, _evalRealm_, _strictCaller_, _direct_)<
1. Let _evalCxt_ be a new ECMAScript code execution context.
1. Set the _evalCxt_'s Function to *null*.
1. Set the _evalCxt_'s Realm to _evalRealm_.
+ 1. Set the _evalCxt_'s ScriptOrModule to _ctx_'s ScriptOrModule.
1. Set the _evalCxt_'s VariableEnvironment to _varEnv_.
1. Set the _evalCxt_'s LexicalEnvironment to _lexEnv_.
1. Push _evalCxt_ on to the execution context stack; _evalCxt_ is now the running execution context.
@@ -34581,7 +34747,7 @@
This Ecma Standard defines the ECMAScript 2016 Language. It is the seventh 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. The sixth edition is the most extensive update to ECMAScript since the publication of the first edition in 1997.
+
Goals for ECMAScript 2016 include 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 include 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 has been 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 are now extensible via subclassing.
+
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.
+
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.
+
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.
+
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 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.
+
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.
+
The fifth edition of ECMAScript (published as ECMA-262 5th 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.
+
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.
+
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.
+
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 informal 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.
+
New uses and requirements for ECMAScript continue to emerge. The sixth edition provides the foundation for regular, incremental language and library enhancements.
+
Allen Wirfs-Brock
+
+ ECMA-262, 6th Edition Project Editor
+
This Ecma Standard has been adopted by the General Assembly of June 2015.
+
+
+
+
+
+
Scope
+
This Standard defines the ECMAScript 2016 general purpose programming language.
+
+
+
+
+
Conformance
+
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.
+
A conforming implementation of ECMAScript must interpret source text input in conformance with the Unicode Standard, Version 5.1.0 or later and ISO/IEC 10646.
+
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.
+
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.
+
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 “future reserved words” listed in subclause of this specification.
+
A conforming implementation of ECMAScript must not implement any extension that is listed as a Forbidden Extension in subclause .
+
+
+
+
+
Normative references
+
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.
+
ISO/IEC 10646:2003: Information Technology – Universal Multiple-Octet Coded Character Set (UCS) plus Amendment 1:2005, Amendment 2:2006, Amendment 3:2008, and Amendment 4:2008, plus additional amendments and corrigenda, or successor
This section contains a non-normative overview of the ECMAScript language.
+
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.
+
ECMAScript was originally designed to be used as a scripting language, but has become widely used as a general purpose programming language. A scripting language 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.
+
ECMAScript was originally designed to be a Web scripting language, 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.
+
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 propose programming language.
+
Some of the facilities of ECMAScript are similar to those used in other programming languages; in particular C, Java™, Self, and Scheme as described in:
+
ISO/IEC 9899:1996, Programming Languages – C.
+
Gosling, James, Bill Joy and Guy Steele. The Java™ Language Specification. Addison Wesley Publishing Co., 1996.
+
Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. OOPSLA '87 Conference Proceedings, pp. 227-241, Orlando, FL, October 1987.
+
IEEE Standard for the Scheme Programming Language. IEEE Std 1178-1990.
+
+
+
+
Web Scripting
+
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.
+
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.
+
Each Web browser and server that supports ECMAScript supplies its own host environment, completing the ECMAScript execution environment.
+
+
+
+
+
ECMAScript Overview
+
The following is an informal overview of ECMAScript—not all parts of the language are described. This overview is not part of the standard proper.
+
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 object is a collection of zero or more properties each with attributes that determine how each property can be used—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, primitive values, or functions. A primitive value is a member of one of the following built-in types: Undefined, Null, Boolean, Number, String, and Symbol; an object is a member of the built-in type Object; and a function is a callable object. A function that is associated with an object via a property is called a method.
+
ECMAScript defines a collection of built-in objects 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`.
+
ECMAScript also defines a set of built-in operators. 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.
+
Large ECMAScript programs are supported by modules 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.
+
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.
+
+
+
+
Objects
+
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 constructors 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 prototype-based inheritance and shared properties. Objects are created by using constructors in new expressions; for example, `new Date(2009,11)` creates a new Date object. Invoking a constructor without using new has consequences that depend on the constructor. For example, `Date()` produces a string representation of the current date and time rather than an object.
+
Every object created by a constructor has an implicit reference (called the object's prototype) 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 prototype chain. 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.
+
+
+
+
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.
+
All objects that do not directly contain a particular property that their prototype contains share that property and its value. Figure 1 illustrates this:
+
CF is a constructor (and also an object). Five objects have been created by using `new` expressions: cf1, cf2, cf3, cf4, and cf5. Each of these objects contains properties named `q1` and `q2`. The dashed lines represent the implicit prototype relationship; so, for example, cf3's prototype is CFp. The constructor, CF, has two properties itself, named `P1` and `P2`, which are not visible to CFp, cf1, cf2, cf3, cf4, or cf5. The property named `CFP1` in CFp is shared by cf1, cf2, cf3, cf4, and cf5 (but not by CF), as are any properties found in CFp's implicit prototype chain that are not named `q1`, `q2`, or `CFP1`. Notice that there is no implicit prototype link between CF and CFp.
+
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 cf1, cf2, cf3, cf4, and cf5 by assigning a new value to the property in CFp.
+
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.
+
+
+
+
+
The Strict Variant of ECMAScript
+
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.
+
The strict variant of ECMAScript is commonly referred to as the strict mode 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.
+
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.
+
+
+
+
+
+
Terms and definitions
+
For the purposes of this document, the following terms and definitions apply.
+
+
+
+
type
+
set of data values as defined in clause of this specification
+
+
+
+
+
primitive value
+
member of one of the types Undefined, Null, Boolean, Number, Symbol, or String as defined in clause
+
+
A primitive value is a datum that is represented directly at the lowest level of the language implementation.
+
+
+
+
+
+
object
+
member of the type Object
+
+
An object is a collection of properties and has a single prototype object. The prototype may be the null value.
+
+
+
+
+
+
constructor
+
function object that creates and initializes objects
+
+
The value of a constructor's `prototype` property is a prototype object that is used to implement inheritance and shared properties.
+
+
+
+
+
+
prototype
+
object that provides shared properties for other objects
+
+
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 constructor.prototype, 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.
+
+
+
+
+
+
ordinary object
+
object that has the default behaviour for the essential internal methods that must be supported by all objects
+
+
+
+
+
exotic object
+
object that does not have the default behaviour for one or more of the essential internal methods that must be supported by all objects
+
+
Any object that is not an ordinary object is an exotic object.
+
+
+
+
+
+
standard object
+
object whose semantics are defined by this specification
+
+
+
+
+
built-in object
+
object specified and supplied by an ECMAScript implementation
+
+
Standard built-in objects are defined in this specification. An ECMAScript implementation may specify and supply additional kinds of built-in objects. A built-in constructor is a built-in object that is also a constructor.
+
+
+
+
+
+
undefined value
+
primitive value used when a variable has not been assigned a value
+
+
+
+
+
Undefined type
+
type whose sole value is the *undefined* value
+
+
+
+
+
null value
+
primitive value that represents the intentional absence of any object value
+
+
+
+
+
Null type
+
type whose sole value is the *null* value
+
+
+
+
+
Boolean value
+
member of the Boolean type
+
+
There are only two Boolean values, *true* and *false*
+
+
+
+
+
+
Boolean type
+
type consisting of the primitive values *true* and *false*
+
+
+
+
+
Boolean object
+
member of the Object type that is an instance of the standard built-in `Boolean` constructor
+
+
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.
+
+
+
+
+
+
String value
+
primitive value that is a finite ordered sequence of zero or more 16-bit unsigned integer
+
+
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.
+
+
+
+
+
+
String type
+
set of all possible String values
+
+
+
+
+
String object
+
member of the Object type that is an instance of the standard built-in `String` constructor
+
+
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 ().
+
+
+
+
+
+
Number value
+
primitive value corresponding to a double-precision 64-bit binary format IEEE 754-2008 value
+
+
A Number value is a member of the Number type and is a direct representation of a number.
+
+
+
+
+
+
Number type
+
set of all possible Number values including the special “Not-a-Number” (NaN) value, positive infinity, and negative infinity
+
+
+
+
+
Number object
+
member of the Object type that is an instance of the standard built-in `Number` constructor
+
+
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 ().
+
+
+
+
+
+
Infinity
+
number value that is the positive infinite number value
+
+
+
+
+
NaN
+
number value that is an IEEE 754-2008 “Not-a-Number” value
+
+
+
+
+
Symbol value
+
primitive value that represents a unique, non-String Object property key
+
+
+
+
+
Symbol type
+
set of all possible Symbol values
+
+
+
+
+
Symbol object
+
member of the Object type that is an instance of the standard built-in `Symbol` constructor
+
+
+
+
+
function
+
member of the Object type that may be invoked as a subroutine
+
+
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.
+
+
+
+
+
+
built-in function
+
built-in object that is a function
+
+
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.
+
+
+
+
+
+
property
+
part of an object that associates a key (either a String value or a Symbol value) and a value
+
+
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.
+
+
+
+
+
+
method
+
function that is the value of a property
+
+
When a function is called as a method of an object, the object is passed to the function as its *this* value.
+
+
+
+
+
+
built-in method
+
method that is a built-in function
+
+
Standard built-in methods are defined in this specification, and an ECMAScript implementation may specify and provide other additional built-in methods.
+
+
+
+
+
+
attribute
+
internal value that defines some characteristic of a property
+
+
+
+
+
own property
+
property that is directly contained by its object
+
+
+
+
+
inherited property
+
property of an object that is not an own property but is a property (either own or inherited) of the object's prototype
+
+
+
+
+
+
Organization of This Specification
+
The remainder of this specification is organized as follows:
+
Clause 5 defines the notational conventions used throughout the specification.
+
Clauses 6-9 define the execution environment within which ECMAScript programs operate.
+
Clauses 10-16 define the actual ECMAScript programming language including its syntactic encoding and the execution semantics of all language features.
+
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.
+
+
+
+
+
+
Notational Conventions
+
+
+
+
Syntactic and Lexical Grammars
+
+
+
+
Context-Free Grammars
+
A context-free grammar consists of a number of productions. Each production has an abstract symbol called a nonterminal as its left-hand side, and a sequence of zero or more nonterminal and terminal symbols as its right-hand side. For each grammar, the terminal symbols are drawn from a specified alphabet.
+
A chain production is a production that has exactly one nonterminal symbol on its right-hand side along with zero or more terminal symbols.
+
Starting from a sentence consisting of a single distinguished nonterminal, called the goal symbol, a given context-free grammar specifies a language, 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.
+
+
+
+
+
The Lexical and RegExp Grammars
+
A lexical grammar for ECMAScript is given in clause . This grammar has as its terminal symbols Unicode code points that conform to the rules for |SourceCharacter| defined in . 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.
+
Input elements other than white space and comments form the terminal symbols for the syntactic grammar for ECMAScript and are called ECMAScript tokens. 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 (). 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 `/*`…`*/` 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.
+
A RegExp grammar for ECMAScript is given in . 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.
+
Productions of the lexical and RegExp grammars are distinguished by having two colons “::” as separating punctuation. The lexical and RegExp grammars share some productions.
+
+
+
+
+
The Numeric String Grammar
+
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 .
+
Productions of the numeric string grammar are distinguished by having three colons “:::” as punctuation.
+
+
+
+
+
The Syntactic Grammar
+
The syntactic grammar 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 (). 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.
+
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.
+
Productions of the syntactic grammar are distinguished by having just one colon “:” as punctuation.
+
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 “awkward” places.
+
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 supplemental grammar 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.
+
+
+
+
+
Grammar Notation
+
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.
+
Nonterminal symbols are shown in _italic_ type. The definition of a nonterminal (also called a “production”) 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:
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:
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.
+
The subscripted suffix “opt”, 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:
so, in this example, the nonterminal |IterationStatement| actually has four alternative right-hand sides.
+
A production may be parameterized by a subscripted annotation of the form “[parameters]”, which may appear as a suffix to the nonterminal symbol defined by the production. “parameters” 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:
Prefixing a parameter name with “?” 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:
If a right-hand side alternative is prefixed with “[+parameter]” 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 “[\~parameter]” that alternative is only available if the named parameter was not used in referencing the production's nonterminal symbol. This means that:
When the words “one of” 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:
+
+ NonZeroDigit :: one of
+ `1` `2` `3` `4` `5` `6` `7` `8` `9`
+
+
If the phrase “[empty]” appears as the right-hand side of a production, it indicates that the production's right-hand side contains no terminals or nonterminals.
+
If the phrase “[lookahead ∉ _set_]” 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 “[lookahead ≠ _terminal_]” may be used.
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.
+
If the phrase “[no |LineTerminator| here]” appears in the right-hand side of a production of the syntactic grammar, it indicates that the production is a restricted production: it may not be used if a |LineTerminator| occurs in the input stream at the indicated position. For example, the production:
indicates that the production may not be used if a |LineTerminator| occurs in the script between the `throw` token and the |Expression|.
+
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.
+
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.
+
The right-hand side of a production may specify that certain expansions are not permitted by using the phrase “but not” and then indicating the expansions to be excluded. For example, the production:
+
+ Identifier ::
+ IdentifierName but not ReservedWord
+
+
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|.
+
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:
+
+ SourceCharacter ::
+ > any Unicode code point
+
+
+
+
+
+
+
Algorithm Conventions
+
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.
+
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 abstract operations, 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_).
+
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 Completion Record returned by the abstract operation. For example, ?operationName() is equivalent to: ReturnIfAbrupt(operationName()). Similarly, ? _someValue_.operationName() is equivalent to ReturnIfAbrupt(_someValue_.operationName()).
+
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.
+
When an algorithm is associated with a production alternative, the alternative is typically shown without any “[ ]” grammar annotations. Such annotations should only affect the syntactic recognition of the alternative and have no effect on the associated semantics for the alternative.
+
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:
+
+ Block :
+ `{` StatementList `}`
+
+
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: “Return the result of evaluating |Block|” it is implicit that an Evaluation algorithm exists of the form:
+
Runtime Semantics: Evaluation
+ Block : `{` StatementList `}`
+
+ 1. Return the result of evaluating |StatementList|.
+
+
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:
A step or substep may be written as an “if” 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 “else”, it is a predicate that is the negation of the preceding “if” predicate step at the same level.
+
A step may specify the iterative application of its substeps.
+
A step that begins with “Assert:” 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.
+
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.
+
The mathematical function abs(_x_) produces the absolute value of _x_, which is -_x_ if _x_ is negative (less than zero) and otherwise is _x_ itself.
+
The mathematical function min(_x1_, _x2_, ..., _xN_) produces the mathematically smallest of _x1_ through _xN_. The mathematical function max(_x1_, _x2_, ..., _xN_) produces the mathematically largest of _x1_ through _xN_. The domain and range of these mathematical functions include *+∞* and *-∞*.
+
The notation “_x_ modulo _y_” (_y_ must be finite and nonzero) computes a value _k_ of the same sign as _y_ (or zero) such that abs(_k_) < abs(_y_) and _x_-_k_ = _q_ × _y_ for some integer _q_.
+
The mathematical function floor(_x_) produces the largest integer (closest to positive infinity) that is not larger than _x_.
+
+
floor(_x_) = _x_-(_x_ modulo 1).
+
+
+
+
+
+
Static Semantic Rules
+
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 static semantics of the production.
+
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.
+
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:
+
+ 1. For each terminal and nonterminal grammar symbol, _sym_, in the definition of this production do
+ 1. If _sym_ is the same grammar symbol as _symbol_, return *true*.
+ 1. If _sym_ is a nonterminal, then
+ 1. Let _contained_ be the result of _sym_ Contains _symbol_.
+ 1. If _contained_ is *true*, return *true*.
+ 1. Return *false*.
+
+
The above definition is explicitly over-ridden for specific productions.
+
A special kind of static semantic rule is an Early Error Rule. Early error rules define early error conditions (see clause ) 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.
+
+
+
+
+
+
ECMAScript Data Types and Values
+
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.
+
Within this specification, the notation “Type(_x_)” is used as shorthand for “the type of _x_” where “type” refers to the ECMAScript language and specification types defined in this clause. When the term “empty” is used as if it was naming a value, it is equivalent to saying “no value of any type”.
+
+
+
+
ECMAScript Language Types
+
An ECMAScript language type 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 ECMAScript language value is a value that is characterized by an ECMAScript language type.
+
+
+
+
The Undefined Type
+
The Undefined type has exactly one value, called *undefined*. Any variable that has not been assigned a value has the value *undefined*.
+
+
+
+
+
The Null Type
+
The Null type has exactly one value, called *null*.
+
+
+
+
+
The Boolean Type
+
The Boolean type represents a logical entity having two values, called *true* and *false*.
+
+
+
+
+
The String Type
+
The String type is the set of all ordered sequences of zero or more 16-bit unsigned integer values (“elements”) up to a maximum length of 253-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.
+
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 ) can be used to explicitly normalize a String value. `String.prototype.localeCompare` (see ) 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.
+
+
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.
+
+
Some operations interpret String contents as UTF-16 encoded Unicode code points. In that case the interpretation is:
+
+
+ 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.
+
+
+ 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) × 0x400 + (_c2_ - 0xDC00) + 0x10000. (See )
+
+
+ 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.
+
+
+
+
+
+
+
The Symbol Type
+
The Symbol type is the set of all non-String values that may be used as the key of an Object property ().
+
Each possible Symbol value is unique and immutable.
+
Each Symbol value immutably holds an associated value called [[Description]] that is either *undefined* or a String value.
+
+
+
+
Well-Known Symbols
+
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 Code Realms ().
+
Within this specification a well-known symbol is referred to by using a notation of the form @@name, where “name” is one of the values listed in .
+
+
+
+
+
+ Specification Name
+
+
+ [[Description]]
+
+
+ Value and Purpose
+
+
+
+
+ @@hasInstance
+
+
+ `"Symbol.hasInstance"`
+
+
+ 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.
+
+
+
+
+ @@isConcatSpreadable
+
+
+ `"Symbol.isConcatSpreadable"`
+
+
+ A Boolean valued property that if true indicates that an object should be flattened to its array elements by `Array.prototype.concat`.
+
+
+
+
+ @@iterator
+
+
+ `"Symbol.iterator"`
+
+
+ A method that returns the default Iterator for an object. Called by the semantics of the for-of statement.
+
+
+
+
+ @@match
+
+
+ `"Symbol.match"`
+
+
+ A regular expression method that matches the regular expression against a string. Called by the `String.prototype.match` method.
+
+
+
+
+ @@replace
+
+
+ `"Symbol.replace"`
+
+
+ A regular expression method that replaces matched substrings of a string. Called by the `String.prototype.replace` method.
+
+
+
+
+ @@search
+
+
+ `"Symbol.search"`
+
+
+ A regular expression method that returns the index within a string that matches the regular expression. Called by the `String.prototype.search` method.
+
+
+
+
+ @@species
+
+
+ `"Symbol.species"`
+
+
+ A function valued property that is the constructor function that is used to create derived objects.
+
+
+
+
+ @@split
+
+
+ `"Symbol.split"`
+
+
+ A regular expression method that splits a string at the indices that match the regular expression. Called by the `String.prototype.split` method.
+
+
+
+
+ @@toPrimitive
+
+
+ `"Symbol.toPrimitive"`
+
+
+ A method that converts an object to a corresponding primitive value. Called by the ToPrimitive abstract operation.
+
+
+
+
+ @@toStringTag
+
+
+ `"Symbol.toStringTag"`
+
+
+ A String valued property that is used in the creation of the default string description of an object. Accessed by the built-in method `Object.prototype.toString`.
+
+
+
+
+ @@unscopables
+
+
+ `"Symbol.unscopables"`
+
+
+ An object valued property whose own property names are property names that are excluded from the `with` environment bindings of the associated object.
+
+
+
+
+
+
+
+
+
+
+
The Number Type
+
The Number type has exactly 18437736874454810627 (that is, 264-253+3) 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, 253-2) distinct “Not-a-Number” 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.
+
+
The bit pattern that might be observed in an ArrayBuffer (see ) 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.
+
+
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 *+∞* and *-∞*, respectively. (Note that these two infinite Number values are produced by the program expressions `+Infinity` (or simply `Infinity`) and `-Infinity`.)
+
The other 18437736874454810624 (that is, 264-253) 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.
+
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`.)
+
The 18437736874454810622 (that is, 264-253-2) finite nonzero values are of two kinds:
+
18428729675200069632 (that is, 264-254) of them are normalized, having the form
+
+ _s_ × _m_ × 2_e_
+
+
where _s_ is +1 or -1, _m_ is a positive integer less than 253 but not less than 252, and _e_ is an integer ranging from -1074 to 971, inclusive.
+
The remaining 9007199254740990 (that is, 253-2) values are denormalized, having the form
+
+ _s_ × _m_ × 2_e_
+
+
where _s_ is +1 or -1, _m_ is a positive integer less than 252, and _e_ is -1074.
+
Note that all the positive and negative integers whose magnitude is no greater than 253 are representable in the Number type (indeed, the integer 0 has two representations, `+0` and `-0`).
+
A finite number has an odd significand 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 even significand.
+
In this specification, the phrase “the Number value for _x_” where _x_ represents an exact nonzero real mathematical quantity (which might even be an irrational number such as π) 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 21024 (which is +1 × 253 × 2971) and -21024 (which is -1 × 253 × 2971). 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 21024 and -21024 are considered to have even significands. Finally, if 21024 was chosen, replace it with *+∞*; if -21024 was chosen, replace it with *-∞*; 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 “round to nearest, ties to even” mode.)
+
Some ECMAScript operators deal only with integers in specific ranges such as -231 through 231-1, inclusive, or in the range 0 through 216-1, 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 .
+
+
+
+
+
The Object Type
+
An Object is logically a collection of properties. Each property is either a data property, or an accessor property:
+
+
+ A data property associates a key value with an ECMAScript language value and a set of Boolean attributes.
+
+
+ An accessor property 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.
+
+
+
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 property name is a property key that is a String value.
+
An integer index is a String-valued property key that is a canonical numeric String (see ) and whose numeric value is either *+0* or a positive integer ≤ 253-1. An array index is an integer index whose numeric value _i_ is in the range +0 ≤ _i_ < 232-1.
+
Property keys are used to access properties and their values. There are two kinds of access for properties: get and set, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both own properties that are a direct part of an object and inherited properties 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.
+
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. Ordinary objects are the most common form of objects and have the default object semantics. An exotic object is any form of object whose property semantics differ in any way from the default semantics.
+
+
+
+
Property Attributes
+
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 .
+
+
+
+
+
+ Attribute Name
+
+
+ Value Domain
+
+
+ Description
+
+
+
+
+ [[Value]]
+
+
+ Any ECMAScript language type
+
+
+ The value retrieved by a get access of the property.
+
+
+
+
+ [[Writable]]
+
+
+ Boolean
+
+
+ If *false*, attempts by ECMAScript code to change the property's [[Value]] attribute using [[Set]] will not succeed.
+
+
+
+
+ [[Enumerable]]
+
+
+ Boolean
+
+
+ If *true*, the property will be enumerated by a for-in enumeration (see ). Otherwise, the property is said to be non-enumerable.
+
+
+
+
+ [[Configurable]]
+
+
+ Boolean
+
+
+ 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.
+
+
+
+
+
+
An accessor property associates a key value with the attributes listed in .
+
+
+
+
+
+ Attribute Name
+
+
+ Value Domain
+
+
+ Description
+
+
+
+
+ [[Get]]
+
+
+ Object | Undefined
+
+
+ If the value is an Object it must be a function object. The function's [[Call]] internal method () is called with an empty arguments list to retrieve the property value each time a get access of the property is performed.
+
+
+
+
+ [[Set]]
+
+
+ Object | Undefined
+
+
+ If the value is an Object it must be a function object. The function's [[Call]] internal method () 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.
+
+
+
+
+ [[Enumerable]]
+
+
+ Boolean
+
+
+ If *true*, the property is to be enumerated by a for-in enumeration (see ). Otherwise, the property is said to be non-enumerable.
+
+
+
+
+ [[Configurable]]
+
+
+ Boolean
+
+
+ If *false*, attempts to delete the property, change the property to be a data property, or change its attributes will fail.
+
+
+
+
+
+
If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined in is used.
+
+
+
+
+
+ Attribute Name
+
+
+ Default Value
+
+
+
+
+ [[Value]]
+
+
+ *undefined*
+
+
+
+
+ [[Get]]
+
+
+ *undefined*
+
+
+
+
+ [[Set]]
+
+
+ *undefined*
+
+
+
+
+ [[Writable]]
+
+
+ *false*
+
+
+
+
+ [[Enumerable]]
+
+
+ *false*
+
+
+
+
+ [[Configurable]]
+
+
+ *false*
+
+
+
+
+
+
+
+
+
+
Object Internal Methods and Internal Slots
+
The actual semantics of objects, in ECMAScript, are specified via algorithms called internal methods. 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.
+
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 “target” 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.
+
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.
+
Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].
+
summarizes the essential internal methods 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.
+
The “Signature” column of 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 “→” and the type name of the returned value. The type names used in signatures refer to the types defined in clause augmented by the following additional names. “any” means the value may be any ECMAScript language type. An internal method implicitly returns a Completion Record as described in . In addition to its parameters, an internal method always has access to the object that is the target of the method invocation.
+
+
+
+
+
+ Internal Method
+
+
+ Signature
+
+
+ Description
+
+
+
+
+ [[GetPrototypeOf]]
+
+
+ () → Object | Null
+
+
+ Determine the object that provides inherited properties for this object. A *null* value indicates that there are no inherited properties.
+
+
+
+
+ [[SetPrototypeOf]]
+
+
+ (Object | Null) → Boolean
+
+
+ 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.
+
+
+
+
+ [[IsExtensible]]
+
+
+ ( ) → Boolean
+
+
+ Determine whether it is permitted to add additional properties to this object.
+
+
+
+
+ [[PreventExtensions]]
+
+
+ ( ) → Boolean
+
+
+ Control whether new properties may be added to this object. Returns *true* if the operation was successful or *false* if the operation was unsuccessful.
+
+ Return a Property Descriptor for the own property of this object whose key is _propertyKey_, or *undefined* if no such property exists.
+
+
+
+
+ [[HasProperty]]
+
+
+ (_propertyKey_) → Boolean
+
+
+ Return a Boolean value indicating whether this object already has either an own or inherited property whose key is _propertyKey_.
+
+
+
+
+ [[Get]]
+
+
+ (_propertyKey_, _Receiver_) →any
+
+
+ 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.
+
+
+
+
+ [[Set]]
+
+
+ (_propertyKey_,_value_, _Receiver_) → Boolean
+
+
+ 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.
+
+
+
+
+ [[Delete]]
+
+
+ (_propertyKey_) → Boolean
+
+
+ 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.
+
+ 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.
+
+
+
+
+ [[Enumerate]]
+
+
+ ()→Object
+
+
+ Return an iterator object that produces the keys of the string-keyed enumerable properties of the object.
+
+
+
+
+ [[OwnPropertyKeys]]
+
+
+ ()→List of propertyKey
+
+
+ Return a List whose elements are all of the own property keys for the object.
+
+
+
+
+
+
summarizes additional essential internal methods that are supported by objects that may be called as functions. A function object is an object that supports the [[Call]] internal methods. A constructor (also referred to as a constructor function) is a function object that supports the [[Construct]] internal method.
+
+
+
+
+
+ Internal Method
+
+
+ Signature
+
+
+ Description
+
+
+
+
+ [[Call]]
+
+
+ (any, a List of any) →any
+
+
+ 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 callable.
+
+
+
+
+ [[Construct]]
+
+
+ (a List of any, Object) → Object
+
+
+ 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 constructors. A function object is not necessarily a constructor and such non-constructor function objects do not have a [[Construct]] internal method.
+
+
+
+
+
+
The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause . 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.
+
+
+
+
+
Invariants of the Essential Internal Methods
+
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.
+
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.
+
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.
+
Definitions:
+
+
+ The target of an internal method is the object upon which the internal method is called.
+
+
+ A target is non-extensible if it has been observed to return false from its [[IsExtensible]] internal method, or true from its [[PreventExtensions]] internal method.
+
+
+ A non-existent property is a property that does not exist as an own property on a non-extensible target.
+
+
+ All references to SameValue are according to the definition of SameValue algorithm specified in .
+
+
+
[[GetPrototypeOf]] ( )
+
+
+ The Type of the return value must be either Object or Null.
+
+
+ If target is non-extensible, and [[GetPrototypeOf]] returns a value v, then any future calls to [[GetPrototypeOf]] should return the SameValue as v.
+
+
+
+
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.
+
+
[[SetPrototypeOf]] (_V_)
+
+
+ The Type of the return value must be Boolean.
+
+
+ If target is non-extensible, [[SetPrototypeOf]] must return false, unless V is the SameValue as the target's observed [[GetPrototypeOf]] value.
+
+
+
[[IsExtensible]] ( )
+
+
+ The Type of the return value must be Boolean.
+
+
+ If [[IsExtensible]] returns false, all future calls to [[IsExtensible]] on the target must return false.
+
+
+
[[PreventExtensions]] ( )
+
+
+ The Type of the return value must be Boolean.
+
+
+ If [[PreventExtensions]] returns true, all future calls to [[IsExtensible]] on the target must return false and the target is now considered non-extensible.
+
+
+
[[GetOwnProperty]] (_P_)
+
+
+ The Type of the return value must be either Property Descriptor or Undefined.
+
+
+ If the Type of the return value is Property Descriptor, the return value must be a complete property descriptor (see ).
+
+
+ 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 ).
+
+
+ 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.
+
+
+ If the [[Writable]] attribute may change from false to true, then the [[Configurable]] attribute must be true.
+
+
+ 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).
+
+
+
+
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.
+
+
[[DefineOwnProperty]] (_P_, _Desc_)
+
+
+ The Type of the return value must be Boolean.
+
+
+ [[DefineOwnProperty]] must return false if P has previously been observed as a non-configurable own property of the target, unless either:
+
+
+ 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.
+
+
+ All attributes in Desc are the SameValue as P's attributes.
+
+
+
+
+ [[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.
+
+
+
[[HasProperty]] ( _P_ )
+
+
+ The Type of the return value must be Boolean.
+
+
+ If P was previously observed as a non-configurable data or accessor own property of the target, [[HasProperty]] must return true.
+
+
+
[[Get]] (_P_, _Receiver_)
+
+
+ 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.
+
+
+ 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.
+
+
+
[[Set]] ( _P_, _V_, _Receiver_)
+
+
+ The Type of the return value must be Boolean.
+
+
+ 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.
+
+
+ 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.
+
+
+
[[Delete]] ( _P_ )
+
+
+ The Type of the return value must be Boolean.
+
+
+ If P was previously observed to be a non-configurable own data or accessor property of the target, [[Delete]] must return false.
+
+
+
[[Enumerate]] ( )
+
+
+ The Type of the return value must be Object.
+
+
+
[[OwnPropertyKeys]] ( )
+
+
+ The return value must be a List.
+
+
+ The Type of each element of the returned List is either String or Symbol.
+
+
+ The returned List must contain at least the keys of all non-configurable own properties that have previously been observed.
+
+
+ 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]].
+
+
+
[[Construct]] ( )
+
+
+ The Type of the return value must be Object.
+
+
+
+
+
+
+
Well-Known Intrinsic Objects
+
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.
+
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 . The well-known intrinsics are listed in .
+
+
+
+
+
+ Intrinsic Name
+
+
+ Global Name
+
+
+ ECMAScript Language Association
+
+
+
+
+ %Array%
+
+
+ `Array`
+
+
+ The `Array` constructor ()
+
+
+
+
+ %ArrayBuffer%
+
+
+ `ArrayBuffer`
+
+
+ The `ArrayBuffer` constructor ()
+
+
+
+
+ %ArrayBufferPrototype%
+
+
+ `ArrayBuffer.prototype`
+
+
+ The initial value of the `prototype` data property of %ArrayBuffer%.
+
+
+
+
+ %ArrayIteratorPrototype%
+
+
+
+
+ The prototype of Array iterator objects ()
+
+
+
+
+ %ArrayPrototype%
+
+
+ `Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Array% ()
+
+
+
+
+ %ArrayProto_values%
+
+
+ `Array.prototype.values`
+
+
+ The initial value of the `values` data property of %ArrayPrototype% ()
+
+
+
+
+ %Boolean%
+
+
+ `Boolean`
+
+
+ The `Boolean` constructor ()
+
+
+
+
+ %BooleanPrototype%
+
+
+ `Boolean.prototype`
+
+
+ The initial value of the `prototype` data property of %Boolean% ()
+
+
+
+
+ %DataView%
+
+
+ `DataView`
+
+
+ The `DataView` constructor ()
+
+
+
+
+ %DataViewPrototype%
+
+
+ `DataView.prototype`
+
+
+ The initial value of the `prototype` data property of %DataView%
+
+
+
+
+ %Date%
+
+
+ `Date`
+
+
+ The `Date` constructor ()
+
+
+
+
+ %DatePrototype%
+
+
+ `Date.prototype`
+
+
+ The initial value of the `prototype` data property of %Date%.
+
+
+
+
+ %decodeURI%
+
+
+ `decodeURI`
+
+
+ The `decodeURI` function ()
+
+
+
+
+ %decodeURIComponent%
+
+
+ `decodeURIComponent`
+
+
+ The `decodeURIComponent` function ()
+
+
+
+
+ %encodeURI%
+
+
+ `encodeURI`
+
+
+ The `encodeURI` function ()
+
+
+
+
+ %encodeURIComponent%
+
+
+ `encodeURIComponent`
+
+
+ The `encodeURIComponent` function ()
+
+
+
+
+ %Error%
+
+
+ `Error`
+
+
+ The `Error` constructor ()
+
+
+
+
+ %ErrorPrototype%
+
+
+ `Error.prototype`
+
+
+ The initial value of the `prototype` data property of %Error%
+
+
+
+
+ %eval%
+
+
+ `eval`
+
+
+ The `eval` function ()
+
+
+
+
+ %EvalError%
+
+
+ `EvalError`
+
+
+ The `EvalError` constructor ()
+
+
+
+
+ %EvalErrorPrototype%
+
+
+ `EvalError.prototype`
+
+
+ The initial value of the `prototype` property of %EvalError%
+
+
+
+
+ %Float32Array%
+
+
+ `Float32Array`
+
+
+ The `Float32Array` constructor ()
+
+
+
+
+ %Float32ArrayPrototype%
+
+
+ `Float32Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Float32Array%.
+
+
+
+
+ %Float64Array%
+
+
+ `Float64Array`
+
+
+ The `Float64Array` constructor ()
+
+
+
+
+ %Float64ArrayPrototype%
+
+
+ `Float64Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Float64Array%
+
+
+
+
+ %Function%
+
+
+ `Function`
+
+
+ The `Function` constructor ()
+
+
+
+
+ %FunctionPrototype%
+
+
+ `Function.prototype`
+
+
+ The initial value of the `prototype` data property of %Function%
+
+
+
+
+ %Generator%
+
+
+
+
+ The initial value of the `prototype` property of %GeneratorFunction%
+
+
+
+
+ %GeneratorFunction%
+
+
+
+
+ The constructor of generator objects ()
+
+
+
+
+ %GeneratorPrototype%
+
+
+
+
+ The initial value of the `prototype` property of %Generator%
+
+
+
+
+ %Int8Array%
+
+
+ `Int8Array`
+
+
+ The `Int8Array` constructor ()
+
+
+
+
+ %Int8ArrayPrototype%
+
+
+ `Int8Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Int8Array%
+
+
+
+
+ %Int16Array%
+
+
+ `Int16Array`
+
+
+ The `Int16Array` constructor ()
+
+
+
+
+ %Int16ArrayPrototype%
+
+
+ `Int16Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Int16Array%
+
+
+
+
+ %Int32Array%
+
+
+ `Int32Array`
+
+
+ The `Int32Array` constructor ()
+
+
+
+
+ %Int32ArrayPrototype%
+
+
+ `Int32Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Int32Array%
+
+
+
+
+ %isFinite%
+
+
+ `isFinite`
+
+
+ The `isFinite` function ()
+
+
+
+
+ %isNaN%
+
+
+ `isNaN`
+
+
+ The `isNaN` function ()
+
+
+
+
+ %IteratorPrototype%
+
+
+
+
+ An object that all standard built-in iterator objects indirectly inherit from
+
+
+
+
+ %JSON%
+
+
+ `JSON`
+
+
+ The `JSON` object ()
+
+
+
+
+ %Map%
+
+
+ `Map`
+
+
+ The `Map` constructor ()
+
+
+
+
+ %MapIteratorPrototype%
+
+
+
+
+ The prototype of Map iterator objects ()
+
+
+
+
+ %MapPrototype%
+
+
+ `Map.prototype`
+
+
+ The initial value of the `prototype` data property of %Map%
+
+
+
+
+ %Math%
+
+
+ `Math`
+
+
+ The `Math` object ()
+
+
+
+
+ %Number%
+
+
+ `Number`
+
+
+ The `Number` constructor ()
+
+
+
+
+ %NumberPrototype%
+
+
+ `Number.prototype`
+
+
+ The initial value of the `prototype` property of %Number%
+
+
+
+
+ %Object%
+
+
+ `Object`
+
+
+ The `Object` constructor ()
+
+
+
+
+ %ObjectPrototype%
+
+
+ `Object.prototype`
+
+
+ The initial value of the `prototype` data property of %Object%. ()
+
+
+
+
+ %ObjProto_toString%
+
+
+ `Object.prototype.toString`
+
+
+ The initial value of the `toString` data property of %ObjectPrototype% ()
+
+
+
+
+ %parseFloat%
+
+
+ `parseFloat`
+
+
+ The `parseFloat` function ()
+
+
+
+
+ %parseInt%
+
+
+ `parseInt`
+
+
+ The `parseInt` function ()
+
+
+
+
+ %Promise%
+
+
+ `Promise`
+
+
+ The `Promise` constructor ()
+
+
+
+
+ %PromisePrototype%
+
+
+ `Promise.prototype`
+
+
+ The initial value of the `prototype` data property of %Promise%
+
+
+
+
+ %Proxy%
+
+
+ `Proxy`
+
+
+ The `Proxy` constructor ()
+
+
+
+
+ %RangeError%
+
+
+ `RangeError`
+
+
+ The `RangeError` constructor ()
+
+
+
+
+ %RangeErrorPrototype%
+
+
+ `RangeError.prototype`
+
+
+ The initial value of the `prototype` property of %RangeError%
+
+
+
+
+ %ReferenceError%
+
+
+ `ReferenceError`
+
+
+ The `ReferenceError` constructor ()
+
+
+
+
+ %ReferenceErrorPrototype%
+
+
+ `ReferenceError.prototype`
+
+
+ The initial value of the `prototype` property of %ReferenceError%
+
+
+
+
+ %Reflect%
+
+
+ `Reflect`
+
+
+ The `Reflect` object ()
+
+
+
+
+ %RegExp%
+
+
+ `RegExp`
+
+
+ The `RegExp` constructor ()
+
+
+
+
+ %RegExpPrototype%
+
+
+ `RegExp.prototype`
+
+
+ The initial value of the `prototype` data property of %RegExp%
+
+
+
+
+ %Set%
+
+
+ `Set`
+
+
+ The `Set` constructor ()
+
+
+
+
+ %SetIteratorPrototype%
+
+
+
+
+ The prototype of Set iterator objects ()
+
+
+
+
+ %SetPrototype%
+
+
+ `Set.prototype`
+
+
+ The initial value of the `prototype` data property of %Set%
+
+
+
+
+ %String%
+
+
+ `String`
+
+
+ The `String` constructor ()
+
+
+
+
+ %StringIteratorPrototype%
+
+
+
+
+ The prototype of String iterator objects ()
+
+
+
+
+ %StringPrototype%
+
+
+ `String.prototype`
+
+
+ The initial value of the `prototype` data property of %String%
+
+
+
+
+ %Symbol%
+
+
+ `Symbol`
+
+
+ The `Symbol` constructor ()
+
+
+
+
+ %SymbolPrototype%
+
+
+ `Symbol.prototype`
+
+
+ The initial value of the `prototype` data property of %Symbol%. ()
+
+
+
+
+ %SyntaxError%
+
+
+ `SyntaxError`
+
+
+ The `SyntaxError` constructor ()
+
+
+
+
+ %SyntaxErrorPrototype%
+
+
+ `SyntaxError.prototype`
+
+
+ The initial value of the `prototype` property of %SyntaxError%
+
+
+
+
+ %ThrowTypeError%
+
+
+
+
+ A function object that unconditionally throws a new instance of %TypeError%
+
+
+
+
+ %TypedArray%
+
+
+
+
+ The super class of all typed Array constructors ()
+
+
+
+
+ %TypedArrayPrototype%
+
+
+
+
+ The initial value of the `prototype` property of %TypedArray%
+
+
+
+
+ %TypeError%
+
+
+ `TypeError`
+
+
+ The `TypeError` constructor ()
+
+
+
+
+ %TypeErrorPrototype%
+
+
+ `TypeError.prototype`
+
+
+ The initial value of the `prototype` property of %TypeError%
+
+
+
+
+ %Uint8Array%
+
+
+ `Uint8Array`
+
+
+ The `Uint8Array` constructor ()
+
+
+
+
+ %Uint8ArrayPrototype%
+
+
+ `Uint8Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Uint8Array%
+
+
+
+
+ %Uint8ClampedArray%
+
+
+ `Uint8ClampedArray`
+
+
+ The `Uint8ClampedArray` constructor ()
+
+
+
+
+ %Uint8ClampedArrayPrototype%
+
+
+ `Uint8ClampedArray.prototype`
+
+
+ The initial value of the `prototype` data property of %Uint8ClampedArray%
+
+
+
+
+ %Uint16Array%
+
+
+ `Uint16Array`
+
+
+ The `Uint16Array` constructor ()
+
+
+
+
+ %Uint16ArrayPrototype%
+
+
+ `Uint16Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Uint16Array%
+
+
+
+
+ %Uint32Array%
+
+
+ `Uint32Array`
+
+
+ The `Uint32Array` constructor ()
+
+
+
+
+ %Uint32ArrayPrototype%
+
+
+ `Uint32Array.prototype`
+
+
+ The initial value of the `prototype` data property of %Uint32Array%
+
+
+
+
+ %URIError%
+
+
+ `URIError`
+
+
+ The `URIError` constructor ()
+
+
+
+
+ %URIErrorPrototype%
+
+
+ `URIError.prototype`
+
+
+ The initial value of the `prototype` property of %URIError%
+
+
+
+
+ %WeakMap%
+
+
+ `WeakMap`
+
+
+ The `WeakMap` constructor ()
+
+
+
+
+ %WeakMapPrototype%
+
+
+ `WeakMap.prototype`
+
+
+ The initial value of the `prototype` data property of %WeakMap%
+
+
+
+
+ %WeakSet%
+
+
+ `WeakSet`
+
+
+ The `WeakSet` constructor ()
+
+
+
+
+ %WeakSetPrototype%
+
+
+ `WeakSet.prototype`
+
+
+ The initial value of the `prototype` data property of %WeakSet%
+
+
+
+
+
+
+
+
+
+
+
+
ECMAScript Specification Types
+
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.
+
+
+
+
The List and Record Specification Type
+
The List type is used to explain the evaluation of argument lists (see ) 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 3rd element of the List _arguments_.
+
For notational convenience within this specification, a literal syntax can be used to express a new List value. For example, « 1, 2 » 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 « ».
+
The Record 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]].
+
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.
+
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 “the field of R named [[field2]]”.
+
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*}.
+
+
+
+
+
The Completion Record Specification Type
+
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.
+
Values of the Completion type are Record values whose fields are defined as by . Such values are referred to as Completion Records.
+
+
+
+
+
+ Field
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[type]]
+
+
+ One of ~normal~, ~break~, ~continue~, ~return~, or ~throw~
+
+
+ The type of completion that occurred.
+
+
+
+
+ [[value]]
+
+
+ any ECMAScript language value or ~empty~
+
+
+ The value that was produced.
+
+
+
+
+ [[target]]
+
+
+ any ECMAScript string or ~empty~
+
+
+ The target label for directed control transfers.
+
+
+
+
+
+
The term “abrupt completion” refers to any completion with a [[type]] value other than ~normal~.
+
+
+
+
NormalCompletion
+
The abstract operation NormalCompletion with a single _argument_, such as:
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:
+
+ 1. Return `"Infinity"`.
+
+
means the same thing as:
+
+ 1. Return NormalCompletion(`"Infinity"`).
+
+
However, if the value expression of a “return” 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 “return” statement simply returns the Completion Record produced by the abstract operation.
+
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:
+
+ 1. Assert: _completionRecord_ is a Completion Record.
+ 1. Return _completionRecord_ as the Completion Record of this abstract operation.
+
+
A “return” statement without a value in an algorithm step means the same thing as:
+
+ 1. Return NormalCompletion(*undefined*).
+
+
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.
+
+
+
+
+
Throw an Exception
+
Algorithms steps that say to throw an exception, such as
+
+ 1. Throw a *TypeError* exception.
+
+
mean the same things as:
+
+ 1. Return Completion{[[type]]: ~throw~, [[value]]: a newly created *TypeError* object, [[target]]:~empty~}.
+
+
+
+
+
+
ReturnIfAbrupt
+
Algorithms steps that say or are otherwise equivalent to:
+
+ 1. ReturnIfAbrupt(_argument_).
+
+
mean the same thing as:
+
+ 1. If _argument_ is an abrupt completion, return _argument_.
+ 1. Else if _argument_ is a Completion Record, let _argument_ be _argument_.[[value]].
+
+
Algorithms steps that say or are otherwise equivalent to:
+
+ 1. ReturnIfAbrupt(AbstractOperation()).
+
+
mean the same thing as:
+
+ 1. Let _hygienicTemp_ be AbstractOperation().
+ 1. If _hygienicTemp_ is an abrupt completion, return _hygienicTemp_.
+ 1. Else if _hygienicTemp_ is a Completion Record, let _hygienicTemp_ be _hygienicTemp_.[[value]].
+
+
Where _hygienicTemp_ is ephemeral and visible only in the steps pertaining to ReturnIfAbrupt.
+
+
+
+
+
UpdateEmpty ( _completionRecord_, _value_)
+
The abstract operation UpdateEmpty with arguments _completionRecord_ and _value_ performs the following steps:
+
+ 1. Assert: If _completionRecord_.[[type]] is either ~return~ or ~throw~ then _completionRecord_.[[value]] is not ~empty~.
+ 1. If _completionRecord_.[[value]] is not ~empty~, return Completion(_completionRecord_).
+ 1. Return Completion{[[type]]: _completionRecord_.[[type]], [[value]]: _value_, [[target]]: _completionRecord_.[[target]] }.
+
+
+
+
+
+
+
The Reference Specification Type
+
+
The Reference type is used to explain the behaviour of such operators as `delete`, `typeof`, the assignment operators, the `super` keyword and other language features. For example, the left-hand operand of an assignment is expected to produce a reference.
+
+
A Reference is a resolved name or property binding. A Reference consists of three components, the base value, the referenced name and the Boolean valued strict reference flag. The base value is either *undefined*, an Object, a Boolean, a String, a Symbol, a Number, or an Environment Record (). A _base_ value of *undefined* indicates that the Reference could not be resolved to a binding. The referenced name is a String or Symbol value.
+
A Super Reference is a Reference that is used to represents a name binding that was expressed using the super keyword. A Super Reference has an additional _thisValue_ component and its _base_ value will never be an Environment Record.
+
The following abstract operations are used in this specification to access the components of references:
+
+
+ GetBase(V). Returns the _base_ value component of the reference V.
+
+
+ GetReferencedName(V). Returns the referenced name component of the reference V.
+
+
+ IsStrictReference(V). Returns the strict reference flag component of the reference V.
+
+
+ HasPrimitiveBase(V). Returns *true* if Type(_base_) is Boolean, String, Symbol, or Number.
+
+
+ IsPropertyReference(V). Returns *true* if either the _base_ value is an object or HasPrimitiveBase(V) is *true*; otherwise returns *false*.
+
+
+ IsUnresolvableReference(V). Returns *true* if the _base_ value is *undefined* and *false* otherwise.
+
+
+ IsSuperReference(V). Returns *true* if this reference has a _thisValue_ component.
+
+
+
The following abstract operations are used in this specification to operate on references:
+
+
+
+
GetValue (_V_)
+
+ 1. ReturnIfAbrupt(_V_).
+ 1. If Type(_V_) is not Reference, return _V_.
+ 1. Let _base_ be GetBase(_V_).
+ 1. If IsUnresolvableReference(_V_), throw a *ReferenceError* exception.
+ 1. If IsPropertyReference(_V_), then
+ 1. If HasPrimitiveBase(_V_) is *true*, then
+ 1. Assert: In this case, _base_ will never be *null* or *undefined*.
+ 1. Let _base_ be ToObject(_base_).
+ 1. Return _base_.[[Get]](GetReferencedName(_V_), GetThisValue(_V_)).
+ 1. Else _base_ must be an Environment Record,
+ 1. Return _base_.GetBindingValue(GetReferencedName(_V_), IsStrictReference(_V_)) (see ).
+
+
+
The object that may be created in step 5.a.ii is not accessible outside of the above abstract operation and the ordinary object [[Get]] internal method. An implementation might choose to avoid the actual creation of the object.
+
+
+
+
+
+
PutValue (_V_, _W_)
+
+ 1. ReturnIfAbrupt(_V_).
+ 1. ReturnIfAbrupt(_W_).
+ 1. If Type(_V_) is not Reference, throw a *ReferenceError* exception.
+ 1. Let _base_ be GetBase(_V_).
+ 1. If IsUnresolvableReference(_V_), then
+ 1. If IsStrictReference(_V_) is *true*, then
+ 1. Throw a *ReferenceError* exception.
+ 1. Let _globalObj_ be GetGlobalObject().
+ 1. Return Set(_globalObj_,GetReferencedName(_V_), _W_, *false*).
+ 1. Else if IsPropertyReference(_V_), then
+ 1. If HasPrimitiveBase(_V_) is *true*, then
+ 1. Assert: In this case, _base_ will never be *null* or *undefined*.
+ 1. Set _base_ to ToObject(_base_).
+ 1. Let _succeeded_ be ? _base_.[[Set]](GetReferencedName(_V_), _W_, GetThisValue(_V_)).
+ 1. If _succeeded_ is *false* and IsStrictReference(_V_) is *true*, throw a *TypeError* exception.
+ 1. Return.
+ 1. Else _base_ must be an Environment Record.
+ 1. Return _base_.SetMutableBinding(GetReferencedName(_V_), _W_, IsStrictReference(_V_)) (see ).
+
+
+
The object that may be created in step 6.a.ii is not accessible outside of the above algorithm and the ordinary object [[Set]] internal method. An implementation might choose to avoid the actual creation of that object.
+
+
+
+
+
+
GetThisValue (_V_)
+
+ 1. Assert: IsPropertyReference(_V_) is *true*.
+ 1. If IsSuperReference(_V_), then
+ 1. Return the value of the _thisValue_ component of the reference _V_.
+ 1. Return GetBase(_V_).
+
+
+
+
+
+
InitializeReferencedBinding (_V_, _W_)
+
+ 1. ReturnIfAbrupt(_V_).
+ 1. ReturnIfAbrupt(_W_).
+ 1. Assert: Type(_V_) is Reference.
+ 1. Assert: IsUnresolvableReference(_V_) is *false*.
+ 1. Let _base_ be GetBase(_V_).
+ 1. Assert: _base_ is an Environment Record.
+ 1. Return _base_.InitializeBinding(GetReferencedName(_V_), _W_).
+
+
+
+
+
+
+
The Property Descriptor Specification Type
+
The Property Descriptor type is used to explain the manipulation and reification of Object property attributes. Values of the Property Descriptor type are Records. Each field's name is an attribute name and its value is a corresponding attribute value as specified in . In addition, any field may be present or absent. The schema name used within this specification to tag literal descriptions of Property Descriptor records is “PropertyDescriptor”.
+
Property Descriptor values may be further classified as data Property Descriptors and accessor Property Descriptors based upon the existence or use of certain fields. A data Property Descriptor is one that includes any fields named either [[Value]] or [[Writable]]. An accessor Property Descriptor is one that includes any fields named either [[Get]] or [[Set]]. Any Property Descriptor may have fields named [[Enumerable]] and [[Configurable]]. A Property Descriptor value may not be both a data Property Descriptor and an accessor Property Descriptor; however, it may be neither. A generic Property Descriptor is a Property Descriptor value that is neither a data Property Descriptor nor an accessor Property Descriptor. A fully populated Property Descriptor is one that is either an accessor Property Descriptor or a data Property Descriptor and that has all of the fields that correspond to the property attributes defined in either or .
+
The following abstract operations are used in this specification to operate upon Property Descriptor values:
+
+
+
+
IsAccessorDescriptor ( _Desc_ )
+
When the abstract operation IsAccessorDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+
+ 1. If _Desc_ is *undefined*, return *false*.
+ 1. If both _Desc_.[[Get]] and _Desc_.[[Set]] are absent, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
IsDataDescriptor ( _Desc_ )
+
When the abstract operation IsDataDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+
+ 1. If _Desc_ is *undefined*, return *false*.
+ 1. If both _Desc_.[[Value]] and _Desc_.[[Writable]] are absent, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
IsGenericDescriptor ( _Desc_ )
+
When the abstract operation IsGenericDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+
+ 1. If _Desc_ is *undefined*, return *false*.
+ 1. If IsAccessorDescriptor(_Desc_) and IsDataDescriptor(_Desc_) are both *false*, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
FromPropertyDescriptor ( _Desc_ )
+
When the abstract operation FromPropertyDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+
+ 1. If _Desc_ is *undefined*, return *undefined*.
+ 1. Let _obj_ be ObjectCreate(%ObjectPrototype%).
+ 1. Assert: _obj_ is an extensible ordinary object with no own properties.
+ 1. If _Desc_ has a [[Value]] field, then
+ 1. Perform CreateDataProperty(_obj_, `"value"`, _Desc_.[[Value]]).
+ 1. If _Desc_ has a [[Writable]] field, then
+ 1. Perform CreateDataProperty(_obj_, `"writable"`, _Desc_.[[Writable]]).
+ 1. If _Desc_ has a [[Get]] field, then
+ 1. Perform CreateDataProperty(_obj_, `"get"`, _Desc_.[[Get]]).
+ 1. If _Desc_ has a [[Set]] field, then
+ 1. Perform CreateDataProperty(_obj_, `"set"`, _Desc_.[[Set]]).
+ 1. If _Desc_ has an [[Enumerable]] field, then
+ 1. Perform CreateDataProperty(_obj_, `"enumerable"`, _Desc_.[[Enumerable]]).
+ 1. If _Desc_ has a [[Configurable]] field, then
+ 1. Perform CreateDataProperty(_obj_ , `"configurable"`, _Desc_.[[Configurable]]).
+ 1. Assert: all of the above CreateDataProperty operations return *true*.
+ 1. Return _obj_.
+
+
+
+
+
+
ToPropertyDescriptor ( _Obj_ )
+
When the abstract operation ToPropertyDescriptor is called with object _Obj_, the following steps are taken:
+
+ 1. ReturnIfAbrupt(_Obj_).
+ 1. If Type(_Obj_) is not Object, throw a *TypeError* exception.
+ 1. Let _desc_ be a new Property Descriptor that initially has no fields.
+ 1. Let _hasEnumerable_ be ? HasProperty(_Obj_, `"enumerable"`).
+ 1. If _hasEnumerable_ is *true*, then
+ 1. Let _enum_ be ToBoolean(? Get(_Obj_, `"enumerable"`)).
+ 1. Set the [[Enumerable]] field of _desc_ to _enum_.
+ 1. Let _hasConfigurable_ be ? HasProperty(_Obj_, `"configurable"`).
+ 1. If _hasConfigurable_ is *true*, then
+ 1. Let _conf_ be ToBoolean(? Get(_Obj_, `"configurable"`)).
+ 1. Set the [[Configurable]] field of _desc_ to _conf_.
+ 1. Let _hasValue_ be ? HasProperty(_Obj_, `"value"`).
+ 1. If _hasValue_ is *true*, then
+ 1. Let _value_ be ? Get(_Obj_, `"value"`).
+ 1. Set the [[Value]] field of _desc_ to _value_.
+ 1. Let _hasWritable_ be ? HasProperty(_Obj_, `"writable"`).
+ 1. If _hasWritable_ is *true*, then
+ 1. Let _writable_ be ToBoolean(? Get(_Obj_, `"writable"`)).
+ 1. Set the [[Writable]] field of _desc_ to _writable_.
+ 1. Let _hasGet_ be ? HasProperty(_Obj_, `"get"`).
+ 1. If _hasGet_ is *true*, then
+ 1. Let _getter_ be ? Get(_Obj_, `"get"`).
+ 1. If IsCallable(_getter_) is *false* and _getter_ is not *undefined*, throw a *TypeError* exception.
+ 1. Set the [[Get]] field of _desc_ to _getter_.
+ 1. Let _hasSet_ be ? HasProperty(_Obj_, `"set"`).
+ 1. If _hasSet_ is *true*, then
+ 1. Let _setter_ be ? Get(_Obj_, `"set"`).
+ 1. If IsCallable(_setter_) is *false* and _setter_ is not *undefined*, throw a *TypeError* exception.
+ 1. Set the [[Set]] field of _desc_ to _setter_.
+ 1. If either _desc_.[[Get]] or _desc_.[[Set]] is present, then
+ 1. If either _desc_.[[Value]] or _desc_.[[Writable]] is present, throw a *TypeError* exception.
+ 1. Return _desc_.
+
+
+
+
+
+
CompletePropertyDescriptor ( _Desc_ )
+
When the abstract operation CompletePropertyDescriptor is called with Property Descriptor _Desc_ the following steps are taken:
+
+ 1. ReturnIfAbrupt(_Desc_).
+ 1. Assert: _Desc_ is a Property Descriptor.
+ 1. Let _like_ be Record{[[Value]]: *undefined*, [[Writable]]: *false*, [[Get]]: *undefined*, [[Set]]: *undefined*, [[Enumerable]]: *false*, [[Configurable]]: *false*}.
+ 1. If either IsGenericDescriptor(_Desc_) or IsDataDescriptor(_Desc_) is *true*, then
+ 1. If _Desc_ does not have a [[Value]] field, set _Desc_.[[Value]] to _like_.[[Value]].
+ 1. If _Desc_ does not have a [[Writable]] field, set _Desc_.[[Writable]] to _like_.[[Writable]].
+ 1. Else,
+ 1. If _Desc_ does not have a [[Get]] field, set _Desc_.[[Get]] to _like_.[[Get]].
+ 1. If _Desc_ does not have a [[Set]] field, set _Desc_.[[Set]] to _like_.[[Set]].
+ 1. If _Desc_ does not have an [[Enumerable]] field, set _Desc_.[[Enumerable]] to _like_.[[Enumerable]].
+ 1. If _Desc_ does not have a [[Configurable]] field, set _Desc_.[[Configurable]] to _like_.[[Configurable]].
+ 1. Return _Desc_.
+
+
+
+
+
+
+
The Lexical Environment and Environment Record Specification Types
+
The Lexical Environment and Environment Record types are used to explain the behaviour of name resolution in nested functions and blocks. These types and the operations upon them are defined in .
+
+
+
+
+
Data Blocks
+
The Data Block specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. A Data Block value is created with a fixed number of bytes that each have the initial value 0.
+
For notational convenience within this specification, an array-like syntax can be used to access the individual bytes of a Data Block value. This notation presents a Data Block value as a 0-origined integer indexed sequence of bytes. For example, if _db_ is a 5 byte Data Block value then _db_[2] can be used to access its 3rd byte.
+
The following abstract operations are used in this specification to operate upon Data Block values:
+
+
+
+
CreateByteDataBlock(_size_)
+
When the abstract operation CreateByteDataBlock is called with integer argument _size_, the following steps are taken:
+
+ 1. Assert: _size_≥0.
+ 1. Let _db_ be a new Data Block value consisting of _size_ bytes. If it is impossible to create such a Data Block, throw a *RangeError* exception.
+ 1. Set all of the bytes of _db_ to 0.
+ 1. Return _db_.
+
+
+
+
+
+
When the abstract operation CopyDataBlockBytes is called the following steps are taken:
+
+ 1. Assert: _fromBlock_ and _toBlock_ are distinct Data Block values.
+ 1. Assert: _fromIndex_, _toIndex_, and _count_ are positive integer values.
+ 1. Let _fromSize_ be the number of bytes in _fromBlock_.
+ 1. Assert: _fromIndex_+_count_ ≤ _fromSize_.
+ 1. Let _toSize_ be the number of bytes in _toBlock_.
+ 1. Assert: _toIndex_+_count_ ≤ _toSize_.
+ 1. Repeat, while _count_>0
+ 1. Set _toBlock_[_toIndex_] to the value of _fromBlock_[_fromIndex_].
+ 1. Increment _toIndex_ and _fromIndex_ each by 1.
+ 1. Decrement _count_ by 1.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
+
+
+
Abstract Operations
+
These operations are not a part of the ECMAScript language; they are defined here to solely to aid the specification of the semantics of the ECMAScript language. Other, more specialized abstract operations are defined throughout this specification.
+
+
+
+
Type Conversion
+
The ECMAScript language implicitly performs automatic type conversion as needed. To clarify the semantics of certain constructs it is useful to define a set of conversion abstract operations. The conversion abstract operations are polymorphic; they can accept a value of any ECMAScript language type or of a Completion Record value. But no other specification types are used with these operations.
+
+
+
+
ToPrimitive ( _input_ [, _PreferredType_] )
+
The abstract operation ToPrimitive takes an _input_ argument and an optional argument _PreferredType_. The abstract operation ToPrimitive converts its _input_ argument to a non-Object type. If an object is capable of converting to more than one primitive type, it may use the optional hint _PreferredType_ to favour that type. Conversion occurs according to :
+
+
+
+
+
+ Input Type
+
+
+ Result
+
+
+
+
+ Completion Record
+
+
+ If _input_ is an abrupt completion, return _input_. Otherwise return ToPrimitive(_input_.[[value]]) also passing the optional hint _PreferredType_.
+
+
+
+
+ Undefined
+
+
+ Return _input_.
+
+
+
+
+ Null
+
+
+ Return _input_.
+
+
+
+
+ Boolean
+
+
+ Return _input_.
+
+
+
+
+ Number
+
+
+ Return _input_.
+
+
+
+
+ String
+
+
+ Return _input_.
+
+
+
+
+ Symbol
+
+
+ Return _input_.
+
+
+
+
+ Object
+
+
+ Perform the steps following this table.
+
+
+
+
+
+
When Type(_input_) is Object, the following steps are taken:
+
+ 1. If _PreferredType_ was not passed, let _hint_ be `"default"`.
+ 1. Else if _PreferredType_ is hint String, let _hint_ be `"string"`.
+ 1. Else _PreferredType_ is hint Number, let _hint_ be `"number"`.
+ 1. Let _exoticToPrim_ be ? GetMethod(_input_, @@toPrimitive).
+ 1. If _exoticToPrim_ is not *undefined*, then
+ 1. Let _result_ be ? Call(_exoticToPrim_, _input_, « _hint_ »).
+ 1. If Type(_result_) is not Object, return _result_.
+ 1. Throw a *TypeError* exception.
+ 1. If _hint_ is `"default"`, let _hint_ be `"number"`.
+ 1. Return OrdinaryToPrimitive(_input_,_hint_).
+
+
When the abstract operation OrdinaryToPrimitive is called with arguments _O_ and _hint_, the following steps are taken:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: Type(_hint_) is String and its value is either `"string"` or `"number"`.
+ 1. If _hint_ is `"string"`, then
+ 1. Let _methodNames_ be « `"toString"`, `"valueOf"` ».
+ 1. Else,
+ 1. Let _methodNames_ be « `"valueOf"`, `"toString"` ».
+ 1. For each _name_ in _methodNames_ in List order, do
+ 1. Let _method_ be ? Get(_O_, _name_).
+ 1. If IsCallable(_method_) is *true*, then
+ 1. Let _result_ be ? Call(_method_, _O_).
+ 1. If Type(_result_) is not Object, return _result_.
+ 1. Throw a *TypeError* exception.
+
+
+
When ToPrimitive is called with no hint, then it generally behaves as if the hint were Number. However, objects may over-ride this behaviour by defining a @@toPrimitive method. Of the objects defined in this specification only Date objects (see ) and Symbol objects (see ) over-ride the default ToPrimitive behaviour. Date objects treat no hint as if the hint were String.
+
+
+
+
+
+
ToBoolean ( _argument_ )
+
The abstract operation ToBoolean converts _argument_ to a value of type Boolean according to :
+
+
+
+
+
+ Argument Type
+
+
+ Result
+
+
+
+
+ Completion Record
+
+
+ If _argument_ is an abrupt completion, return _argument_. Otherwise return ToBoolean(_argument_.[[value]]).
+
+
+
+
+ Undefined
+
+
+ Return *false*.
+
+
+
+
+ Null
+
+
+ Return *false*.
+
+
+
+
+ Boolean
+
+
+ Return _argument_.
+
+
+
+
+ Number
+
+
+ Return *false* if _argument_ is *+0*, *-0*, or *NaN*; otherwise return *true*.
+
+
+
+
+ String
+
+
+ Return *false* if _argument_ is the empty String (its length is zero); otherwise return *true*.
+
+
+
+
+ Symbol
+
+
+ Return *true*.
+
+
+
+
+ Object
+
+
+ Return *true*.
+
+
+
+
+
+
+
+
+
+
ToNumber ( _argument_ )
+
The abstract operation ToNumber converts _argument_ to a value of type Number according to :
+
+
+
+
+
+ Argument Type
+
+
+ Result
+
+
+
+
+ Completion Record
+
+
+ If _argument_ is an abrupt completion, return _argument_. Otherwise return ToNumber(_argument_.[[value]]).
+
+
+
+
+ Undefined
+
+
+ Return *NaN*.
+
+
+
+
+ Null
+
+
+ Return *+0*.
+
+
+
+
+ Boolean
+
+
+ Return 1 if _argument_ is *true*. Return *+0* if _argument_ is *false*.
+
+
+
+
+ Number
+
+
+ Return _argument_ (no conversion).
+
+
+
+
+ String
+
+
+ See grammar and conversion algorithm below.
+
+
+
+
+ Symbol
+
+
+ Throw a *TypeError* exception.
+
+
+
+
+ Object
+
+
+
Apply the following steps:
+
+ 1. Let _primValue_ be ToPrimitive(_argument_, hint Number).
+ 1. Return ToNumber(_primValue_).
+
+
+
+
+
+
+
+
+
+
ToNumber Applied to the String Type
+
ToNumber applied to Strings applies the following grammar to the input String interpreted as a sequence of UTF-16 encoded code points (). If the grammar cannot interpret the String as an expansion of |StringNumericLiteral|, then the result of ToNumber is *NaN*.
+
+
The terminal symbols of this grammar are all composed of Unicode BMP code points so the result will be *NaN* if the string contains the UTF-16 encoding of any supplementary code points or any unpaired surrogate code points.
All grammar symbols not explicitly defined above have the definitions used in the Lexical Grammar for numeric literals ()
+
+
Some differences should be noted between the syntax of a |StringNumericLiteral| and a |NumericLiteral| (see ):
+
+
+ A |StringNumericLiteral| may include leading and/or trailing white space and/or line terminators.
+
+
+ A |StringNumericLiteral| that is decimal may have any number of leading `0` digits.
+
+
+ A |StringNumericLiteral| that is decimal may include a `+` or `-` to indicate its sign.
+
+
+ A |StringNumericLiteral| that is empty or contains only white space is converted to *+0*.
+
+
+ `Infinity` and `-Infinity` are recognized as a |StringNumericLiteral| but not as a |NumericLiteral|.
+
+
+
+
+
+
+
Runtime Semantics: MV's
+
The conversion of a String to a Number value is similar overall to the determination of the Number value for a numeric literal (see ), but some of the details are different, so the process for converting a String numeric literal to a value of Number type is given here. This value is determined in two steps: first, a mathematical value (MV) is derived from the String numeric literal; second, this mathematical value is rounded as described below. The MV on any grammar symbol, not provided below, is the MV for that symbol defined in .
+
+
+ The MV of StringNumericLiteral ::: [empty] is 0.
+
+
+ The MV of StringNumericLiteral ::: StrWhiteSpace is 0.
+
+
+ The MV of StringNumericLiteral ::: StrWhiteSpace? StrNumericLiteral StrWhiteSpace? is the MV of |StrNumericLiteral|, no matter whether white space is present or not.
+
+
+ The MV of StrNumericLiteral ::: StrDecimalLiteral is the MV of |StrDecimalLiteral|.
+
+
+ The MV of StrNumericLiteral ::: BinaryIntegerLiteral is the MV of |BinaryIntegerLiteral|.
+
+
+ The MV of StrNumericLiteral ::: OctalIntegerLiteral is the MV of |OctalIntegerLiteral|.
+
+
+ The MV of StrNumericLiteral ::: HexIntegerLiteral is the MV of |HexIntegerLiteral|.
+
+
+ The MV of StrDecimalLiteral ::: StrUnsignedDecimalLiteral is the MV of |StrUnsignedDecimalLiteral|.
+
+
+ The MV of StrDecimalLiteral ::: `+` StrUnsignedDecimalLiteral is the MV of |StrUnsignedDecimalLiteral|.
+
+
+ The MV of StrDecimalLiteral ::: `-` StrUnsignedDecimalLiteral is the negative of the MV of |StrUnsignedDecimalLiteral|. (Note that if the MV of |StrUnsignedDecimalLiteral| is 0, the negative of this MV is also 0. The rounding rule described below handles the conversion of this signless mathematical zero to a floating-point *+0* or *-0* as appropriate.)
+
+
+ The MV of StrUnsignedDecimalLiteral ::: `Infinity` is 1010000 (a value so large that it will round to *+∞*).
+
+
+ The MV of StrUnsignedDecimalLiteral ::: DecimalDigits `.` is the MV of |DecimalDigits|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: DecimalDigits `.` DecimalDigits is the MV of the first |DecimalDigits| plus (the MV of the second |DecimalDigits| times 10-_n_), where _n_ is the number of code points in the second |DecimalDigits|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: DecimalDigits `.` ExponentPart is the MV of |DecimalDigits| times 10_e_, where _e_ is the MV of |ExponentPart|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: DecimalDigits `.` DecimalDigits ExponentPart is (the MV of the first |DecimalDigits| plus (the MV of the second |DecimalDigits| times 10-_n_)) times 10_e_, where _n_ is the number of code points in the second |DecimalDigits| and _e_ is the MV of |ExponentPart|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: `.` DecimalDigits is the MV of |DecimalDigits| times 10-_n_, where _n_ is the number of code points in |DecimalDigits|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: `.` DecimalDigits ExponentPart is the MV of |DecimalDigits| times 10_e_-_n_, where _n_ is the number of code points in |DecimalDigits| and _e_ is the MV of |ExponentPart|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: DecimalDigits is the MV of |DecimalDigits|.
+
+
+ The MV of StrUnsignedDecimalLiteral ::: DecimalDigits ExponentPart is the MV of |DecimalDigits| times 10_e_, where _e_ is the MV of |ExponentPart|.
+
+
+
Once the exact MV for a String numeric literal has been determined, it is then rounded to a value of the Number type. If the MV is 0, then the rounded value is +0 unless the first non white space code point in the String numeric literal is `"-"`, in which case the rounded value is -0. Otherwise, the rounded value must be the Number value for the MV (in the sense defined in ), unless the literal includes a |StrUnsignedDecimalLiteral| and the literal has more than 20 significant digits, in which case the Number value may be either the Number value for the MV of a literal produced by replacing each significant digit after the 20th with a 0 digit or the Number value for the MV of a literal produced by replacing each significant digit after the 20th with a 0 digit and then incrementing the literal at the 20th digit position. A digit is significant if it is not part of an |ExponentPart| and
+
+
+ it is not `0`; or
+
+
+ there is a nonzero digit to its left and there is a nonzero digit, not in the |ExponentPart|, to its right.
+
+
+
+
+
+
+
+
+
ToInteger ( _argument_ )
+
The abstract operation ToInteger converts _argument_ to an integral numeric value. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, return *+0*.
+ 1. If _number_ is *+0*, *-0*, *+∞*, or *-∞*, return _number_.
+ 1. Return the number value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+
+
+
+
+
+
ToInt32 ( _argument_ )
+
The abstract operation ToInt32 converts _argument_ to one of 232 integer values in the range -231 through 231-1, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, *+0*, *-0*, *+∞*, or *-∞*, return *+0*.
+ 1. Let _int_ be the mathematical value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+ 1. Let _int32bit_ be _int_ modulo 232.
+ 1. If _int32bit_ ≥ 231, return _int32bit_ - 232; otherwise return _int32bit_.
+
+
+
Given the above definition of ToInt32:
+
+
+ The ToInt32 abstract operation is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
+
+
+ ToInt32(ToUint32(_x_)) is equal to ToInt32(_x_) for all values of _x_. (It is to preserve this latter property that *+∞* and *-∞* are mapped to *+0*.)
+
+
+ ToInt32 maps *-0* to *+0*.
+
+
+
+
+
+
+
+
ToUint32 ( _argument_ )
+
The abstract operation ToUint32 converts _argument_ to one of 232 integer values in the range 0 through 232-1, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, *+0*, *-0*, *+∞*, or *-∞*, return *+0*.
+ 1. Let _int_ be the mathematical value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+ 1. Let _int32bit_ be _int_ modulo 232.
+ 1. Return _int32bit_.
+
+
+
Given the above definition of ToUint32:
+
+
+ Step 5 is the only difference between ToUint32 and ToInt32.
+
+
+ The ToUint32 abstract operation is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
+
+
+ ToUint32(ToInt32(_x_)) is equal to ToUint32(_x_) for all values of _x_. (It is to preserve this latter property that *+∞* and *-∞* are mapped to *+0*.)
+
+
+ ToUint32 maps *-0* to *+0*.
+
+
+
+
+
+
+
+
ToInt16 ( _argument_ )
+
The abstract operation ToInt16 converts _argument_ to one of 216 integer values in the range -32768 through 32767, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, *+0*, *-0*, *+∞*, or *-∞*, return *+0*.
+ 1. Let _int_ be the mathematical value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+ 1. Let _int16bit_ be _int_ modulo 216.
+ 1. If _int16bit_ ≥ 215, return _int16bit_ - 216; otherwise return _int16bit_.
+
+
+
+
+
+
ToUint16 ( _argument_ )
+
The abstract operation ToUint16 converts _argument_ to one of 216 integer values in the range 0 through 216-1, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, *+0*, *-0*, *+∞*, or *-∞*, return *+0*.
+ 1. Let _int_ be the mathematical value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+ 1. Let _int16bit_ be _int_ modulo 216.
+ 1. Return _int16bit_.
+
+
+
Given the above definition of ToUint16:
+
+
+ The substitution of 216 for 232 in step 4 is the only difference between ToUint32 and ToUint16.
+
+
+ ToUint16 maps *-0* to *+0*.
+
+
+
+
+
+
+
+
ToInt8 ( _argument_ )
+
The abstract operation ToInt8 converts _argument_ to one of 28 integer values in the range -128 through 127, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, *+0*, *-0*, *+∞*, or *-∞*, return *+0*.
+ 1. Let _int_ be the mathematical value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+ 1. Let _int8bit_ be _int_ modulo 28.
+ 1. If _int8bit_ ≥ 27, return _int8bit_ - 28; otherwise return _int8bit_.
+
+
+
+
+
+
ToUint8 ( _argument_ )
+
The abstract operation ToUint8 converts _argument_ to one of 28 integer values in the range 0 through 255, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, *+0*, *-0*, *+∞*, or *-∞*, return *+0*.
+ 1. Let _int_ be the mathematical value that is the same sign as _number_ and whose magnitude is floor(abs(_number_)).
+ 1. Let _int8bit_ be _int_ modulo 28.
+ 1. Return _int8bit_.
+
+
+
+
+
+
ToUint8Clamp ( _argument_ )
+
The abstract operation ToUint8Clamp converts _argument_ to one of 28 integer values in the range 0 through 255, inclusive. This abstract operation functions as follows:
+
+ 1. Let _number_ be ? ToNumber(_argument_).
+ 1. If _number_ is *NaN*, return *+0*.
+ 1. If _number_ ≤ 0, return *+0*.
+ 1. If _number_ ≥ 255, return 255.
+ 1. Let _f_ be floor(_number_).
+ 1. If _f_ + 0.5 < _number_, return _f_ + 1.
+ 1. If _number_ < _f_ + 0.5, return _f_.
+ 1. If _f_ is odd, return _f_ + 1.
+ 1. Return _f_.
+
+
+
Unlike the other ECMAScript integer conversion abstract operation, ToUint8Clamp rounds rather than truncates non-integer values and does not convert *+∞* to 0. ToUint8Clamp does “round half to even” tie-breaking. This differs from `Math.round` which does “round half up” tie-breaking.
+
+
+
+
+
+
ToString ( _argument_ )
+
The abstract operation ToString converts _argument_ to a value of type String according to :
+
+
+
+
+
+ Argument Type
+
+
+ Result
+
+
+
+
+ Completion Record
+
+
+ If _argument_ is an abrupt completion, return _argument_. Otherwise return ToString(_argument_.[[value]]).
+
+
+
+
+ Undefined
+
+
+ Return `"undefined"`.
+
+
+
+
+ Null
+
+
+ Return `"null"`.
+
+
+
+
+ Boolean
+
+
+
If _argument_ is *true*, return `"true"`.
+
If _argument_ is *false*, return `"false"`.
+
+
+
+
+ Number
+
+
+ See .
+
+
+
+
+ String
+
+
+ Return _argument_.
+
+
+
+
+ Symbol
+
+
+ Throw a *TypeError* exception.
+
+
+
+
+ Object
+
+
+
Apply the following steps:
+
+ 1. Let _primValue_ be ToPrimitive(_argument_, hint String).
+ 1. Return ToString(_primValue_).
+
+
+
+
+
+
+
+
+
+
ToString Applied to the Number Type
+
The abstract operation ToString converts a Number _m_ to String format as follows:
+
+ 1. If _m_ is *NaN*, return the String `"NaN"`.
+ 1. If _m_ is *+0* or *-0*, return the String `"0"`.
+ 1. If _m_ is less than zero, return the String concatenation of the String `"-"` and ToString(-_m_).
+ 1. If _m_ is *+∞*, return the String `"Infinity"`.
+ 1. Otherwise, let _n_, _k_, and _s_ be integers such that _k_ ≥ 1, 10_k_-1 ≤ _s_ < 10_k_, the Number value for _s_ × 10_n_-_k_ is _m_, and _k_ is as small as possible. Note that _k_ is the number of digits in the decimal representation of _s_, that _s_ is not divisible by 10, and that the least significant digit of _s_ is not necessarily uniquely determined by these criteria.
+ 1. If _k_ ≤ _n_ ≤ 21, return the String consisting of the code units of the _k_ digits of the decimal representation of _s_ (in order, with no leading zeroes), followed by _n_-_k_ occurrences of the code unit 0x0030 (DIGIT ZERO).
+ 1. If 0 < _n_ ≤ 21, return the String consisting of the code units of the most significant _n_ digits of the decimal representation of _s_, followed by the code unit 0x002E (FULL STOP), followed by the code units of the remaining _k_-_n_ digits of the decimal representation of _s_.
+ 1. If -6 < _n_ ≤ 0, return the String consisting of the code unit 0x0030 (DIGIT ZERO), followed by the code unit 0x002E (FULL STOP), followed by -_n_ occurrences of the code unit 0x0030 (DIGIT ZERO), followed by the code units of the _k_ digits of the decimal representation of _s_.
+ 1. Otherwise, if _k_ = 1, return the String consisting of the code unit of the single digit of _s_, followed by code unit 0x0065 (LATIN SMALL LETTER E), followed by the code unit 0x002B (PLUS SIGN) or the code unit 0x002D (HYPHEN-MINUS) according to whether _n_-1 is positive or negative, followed by the code units of the decimal representation of the integer abs(_n_-1) (with no leading zeroes).
+ 1. Return the String consisting of the code units of the most significant digit of the decimal representation of _s_, followed by code unit 0x002E (FULL STOP), followed by the code units of the remaining _k_-1 digits of the decimal representation of _s_, followed by code unit 0x0065 (LATIN SMALL LETTER E), followed by code unit 0x002B (PLUS SIGN) or the code unit 0x002D (HYPHEN-MINUS) according to whether _n_-1 is positive or negative, followed by the code units of the decimal representation of the integer abs(_n_-1) (with no leading zeroes).
+
+
+
The following observations may be useful as guidelines for implementations, but are not part of the normative requirements of this Standard:
+
+
+ If x is any Number value other than *-0*, then ToNumber(ToString(x)) is exactly the same Number value as x.
+
+
+ The least significant digit of s is not always uniquely determined by the requirements listed in step 5.
+
+
+
+
+
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step 5 be used as a guideline:
+
+ 5. Otherwise, let _n_, _k_, and _s_ be integers such that _k_ ≥ 1, 10_k_-1 ≤ _s_ < 10_k_, the Number value for _s_ × 10_n_-_k_ is _m_, and _k_ is as small as possible. If there are multiple possibilities for _s_, choose the value of _s_ for which _s_ × 10_n_-_k_ is closest in value to _m_. If there are two such possible values of _s_, choose the one that is even. Note that _k_ is the number of digits in the decimal representation of _s_ and that _s_ is not divisible by 10.
+
+
+
+
Implementers of ECMAScript may find useful the paper and code written by David M. Gay for binary-to-decimal conversion of floating-point numbers:
The abstract operation ToObject converts _argument_ to a value of type Object according to :
+
+
+
+
+
+ Argument Type
+
+
+ Result
+
+
+
+
+ Completion Record
+
+
+ If _argument_ is an abrupt completion, return _argument_. Otherwise return ToObject(_argument_.[[value]]).
+
+
+
+
+ Undefined
+
+
+ Throw a *TypeError* exception.
+
+
+
+
+ Null
+
+
+ Throw a *TypeError* exception.
+
+
+
+
+ Boolean
+
+
+ Return a new Boolean object whose [[BooleanData]] internal slot is set to the value of _argument_. See for a description of Boolean objects.
+
+
+
+
+ Number
+
+
+ Return a new Number object whose [[NumberData]] internal slot is set to the value of _argument_. See for a description of Number objects.
+
+
+
+
+ String
+
+
+ Return a new String object whose [[StringData]] internal slot is set to the value of _argument_. See for a description of String objects.
+
+
+
+
+ Symbol
+
+
+ Return a new Symbol object whose [[SymbolData]] internal slot is set to the value of _argument_. See for a description of Symbol objects.
+
+
+
+
+ Object
+
+
+ Return _argument_.
+
+
+
+
+
+
+
+
+
+
ToPropertyKey ( _argument_ )
+
The abstract operation ToPropertyKey converts _argument_ to a value that can be used as a property key by performing the following steps:
+
+ 1. Let _key_ be ? ToPrimitive(_argument_, hint String).
+ 1. If Type(_key_) is Symbol, then
+ 1. Return _key_.
+ 1. Return ToString(_key_).
+
+
+
+
+
+
ToLength ( _argument_ )
+
The abstract operation ToLength converts _argument_ to an integer suitable for use as the length of an array-like object. It performs the following steps:
+
+ 1. ReturnIfAbrupt(_argument_).
+ 1. Let _len_ be ? ToInteger(_argument_).
+ 1. If _len_ ≤ +0, return +0.
+ 1. If _len_ is *+∞*, return 253-1.
+ 1. Return min(_len_, 253-1).
+
+
+
+
+
+
CanonicalNumericIndexString ( _argument_ )
+
The abstract operation CanonicalNumericIndexString returns _argument_ converted to a numeric value if it is a String representation of a Number that would be produced by ToString, or the string `"-0"`. Otherwise, it returns *undefined*. This abstract operation functions as follows:
+
+ 1. Assert: Type(_argument_) is String.
+ 1. If _argument_ is `"-0"`, return -0.
+ 1. Let _n_ be ToNumber(_argument_).
+ 1. If SameValue(ToString(_n_), _argument_) is *false*, return *undefined*.
+ 1. Return _n_.
+
+
A canonical numeric string is any String value for which the CanonicalNumericIndexString abstract operation does not return *undefined*.
+
+
+
+
+
+
Testing and Comparison Operations
+
+
+
+
RequireObjectCoercible ( _argument_ )
+
The abstract operation RequireObjectCoercible throws an error if _argument_ is a value that cannot be converted to an Object using ToObject. It is defined by :
+
+
+
+
+
+ Argument Type
+
+
+ Result
+
+
+
+
+ Completion Record
+
+
+ If _argument_ is an abrupt completion, return _argument_. Otherwise return RequireObjectCoercible(_argument_.[[value]]).
+
+
+
+
+ Undefined
+
+
+ Throw a *TypeError* exception.
+
+
+
+
+ Null
+
+
+ Throw a *TypeError* exception.
+
+
+
+
+ Boolean
+
+
+ Return _argument_.
+
+
+
+
+ Number
+
+
+ Return _argument_.
+
+
+
+
+ String
+
+
+ Return _argument_.
+
+
+
+
+ Symbol
+
+
+ Return _argument_.
+
+
+
+
+ Object
+
+
+ Return _argument_.
+
+
+
+
+
+
+
+
+
+
IsArray ( _argument_ )
+
The abstract operation IsArray takes one argument _argument_, and performs the following steps:
+
+ 1. If Type(_argument_) is not Object, return *false*.
+ 1. If _argument_ is an Array exotic object, return *true*.
+ 1. If _argument_ is a Proxy exotic object, then
+ 1. If the value of the [[ProxyHandler]] internal slot of _argument_ is *null*, throw a *TypeError* exception.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _argument_.
+ 1. Return IsArray(_target_).
+ 1. Return *false*.
+
+
+
+
+
+
IsCallable ( _argument_ )
+
The abstract operation IsCallable determines if _argument_, which must be an ECMAScript language value or a Completion Record, is a callable function with a [[Call]] internal method.
+
+ 1. ReturnIfAbrupt(_argument_).
+ 1. If Type(_argument_) is not Object, return *false*.
+ 1. If _argument_ has a [[Call]] internal method, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
IsConstructor ( _argument_ )
+
The abstract operation IsConstructor determines if _argument_, which must be an ECMAScript language value or a Completion Record, is a function object with a [[Construct]] internal method.
+
+ 1. ReturnIfAbrupt(_argument_).
+ 1. If Type(_argument_) is not Object, return *false*.
+ 1. If _argument_ has a [[Construct]] internal method, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
IsExtensible (_O_)
+
The abstract operation IsExtensible is used to determine whether additional properties can be added to the object that is _O_. A Boolean value is returned. This abstract operation performs the following steps:
The abstract operation IsInteger determines if _argument_ is a finite integer numeric value.
+
+ 1. ReturnIfAbrupt(_argument_).
+ 1. If Type(_argument_) is not Number, return *false*.
+ 1. If _argument_ is *NaN*, *+∞*, or *-∞*, return *false*.
+ 1. If floor(abs(_argument_)) ≠ abs(_argument_), return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
IsPropertyKey ( _argument_ )
+
The abstract operation IsPropertyKey determines if _argument_, which must be an ECMAScript language value or a Completion Record, is a value that may be used as a property key.
+
+ 1. ReturnIfAbrupt(_argument_).
+ 1. If Type(_argument_) is String, return *true*.
+ 1. If Type(_argument_) is Symbol, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
IsRegExp ( _argument_ )
+
The abstract operation IsRegExp with argument _argument_ performs the following steps:
+
+ 1. If Type(_argument_) is not Object, return *false*.
+ 1. Let _isRegExp_ be ? Get(_argument_, @@match).
+ 1. If _isRegExp_ is not *undefined*, return ToBoolean(_isRegExp_).
+ 1. If _argument_ has a [[RegExpMatcher]] internal slot, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
SameValue(_x_, _y_)
+
The internal comparison abstract operation SameValue(_x_, _y_), where _x_ and _y_ are ECMAScript language values, produces *true* or *false*. Such a comparison is performed as follows:
+
+ 1. ReturnIfAbrupt(_x_).
+ 1. ReturnIfAbrupt(_y_).
+ 1. If Type(_x_) is different from Type(_y_), return *false*.
+ 1. If Type(_x_) is Number, then
+ 1. If _x_ is *NaN* and _y_ is *NaN*, return *true*.
+ 1. If _x_ is *+0* and _y_ is *-0*, return *false*.
+ 1. If _x_ is *-0* and _y_ is *+0*, return *false*.
+ 1. If _x_ is the same Number value as _y_, return *true*.
+ 1. Return *false*.
+ 1. Return SameValueNonNumber(_x_, _y_).
+
+
+
This algorithm differs from the Strict Equality Comparison Algorithm () in its treatment of signed zeroes and NaNs.
+
+
+
+
+
+
SameValueZero(_x_, _y_)
+
The internal comparison abstract operation SameValueZero(_x_, _y_), where _x_ and _y_ are ECMAScript language values, produces *true* or *false*. Such a comparison is performed as follows:
+
+ 1. ReturnIfAbrupt(_x_).
+ 1. ReturnIfAbrupt(_y_).
+ 1. If Type(_x_) is different from Type(_y_), return *false*.
+ 1. If Type(_x_) is Number, then
+ 1. If _x_ is *NaN* and _y_ is *NaN*, return *true*.
+ 1. If _x_ is *+0* and _y_ is *-0*, return *true*.
+ 1. If _x_ is *-0* and _y_ is *+0*, return *true*.
+ 1. If _x_ is the same Number value as _y_, return *true*.
+ 1. Return *false*.
+ 1. Return SameValueNonNumber(_x_, _y_).
+
+
+
SameValueZero differs from SameValue only in its treatment of *+0* and *-0*.
+
+
+
+
+
SameValueNonNumber(_x_, _y_)
+
The internal comparison abstract operation SameValueNonNumber(_x_, _y_), where neither _x_ nor _y_ are Number values, produces *true* or *false*. Such a comparison is performed as follows:
+
+ 1. ReturnIfAbrupt(_x_).
+ 1. ReturnIfAbrupt(_y_).
+ 1. Assert: Type(_x_) is not Number.
+ 1. Assert: Type(_x_) is the same as Type(_y_).
+ 1. If Type(_x_) is Undefined, return *true*.
+ 1. If Type(_x_) is Null, return *true*.
+ 1. If Type(_x_) is String, then
+ 1. If _x_ and _y_ are exactly the same sequence of code units (same length and same code units at corresponding indices), return *true*; otherwise, return *false*.
+ 1. If Type(_x_) is Boolean, then
+ 1. If _x_ and _y_ are both *true* or both *false*, return *true*; otherwise, return *false*.
+ 1. If Type(_x_) is Symbol, then
+ 1. If _x_ and _y_ are both the same Symbol value, return *true*; otherwise, return *false*.
+ 1. Return *true* if _x_ and _y_ are the same Object value. Otherwise, return *false*.
+
+
+
+
+
+
Abstract Relational Comparison
+
The comparison _x_ < _y_, where _x_ and _y_ are values, produces *true*, *false*, or *undefined* (which indicates that at least one operand is *NaN*). In addition to _x_ and _y_ the algorithm takes a Boolean flag named _LeftFirst_ as a parameter. The flag is used to control the order in which operations with potentially visible side-effects are performed upon _x_ and _y_. It is necessary because ECMAScript specifies left to right evaluation of expressions. The default value of _LeftFirst_ is *true* and indicates that the _x_ parameter corresponds to an expression that occurs to the left of the _y_ parameter's corresponding expression. If _LeftFirst_ is *false*, the reverse is the case and operations must be performed upon _y_ before _x_. Such a comparison is performed as follows:
+
+ 1. ReturnIfAbrupt(_x_).
+ 1. ReturnIfAbrupt(_y_).
+ 1. If the _LeftFirst_ flag is *true*, then
+ 1. Let _px_ be ? ToPrimitive(_x_, hint Number).
+ 1. Let _py_ be ? ToPrimitive(_y_, hint Number).
+ 1. Else the order of evaluation needs to be reversed to preserve left to right evaluation
+ 1. Let _py_ be ? ToPrimitive(_y_, hint Number).
+ 1. Let _px_ be ? ToPrimitive(_x_, hint Number).
+ 1. If both _px_ and _py_ are Strings, then
+ 1. If _py_ is a prefix of _px_, return *false*. (A String value _p_ is a prefix of String value _q_ if _q_ can be the result of concatenating _p_ and some other String _r_. Note that any String is a prefix of itself, because _r_ may be the empty String.)
+ 1. If _px_ is a prefix of _py_, return *true*.
+ 1. Let _k_ be the smallest nonnegative integer such that the code unit at index _k_ within _px_ is different from the code unit at index _k_ within _py_. (There must be such a _k_, for neither String is a prefix of the other.)
+ 1. Let _m_ be the integer that is the code unit value at index _k_ within _px_.
+ 1. Let _n_ be the integer that is the code unit value at index _k_ within _py_.
+ 1. If _m_ < _n_, return *true*. Otherwise, return *false*.
+ 1. Else,
+ 1. Let _nx_ be ? ToNumber(_px_). Because _px_ and _py_ are primitive values evaluation order is not important.
+ 1. Let _ny_ be ? ToNumber(_py_).
+ 1. If _nx_ is *NaN*, return *undefined*.
+ 1. If _ny_ is *NaN*, return *undefined*.
+ 1. If _nx_ and _ny_ are the same Number value, return *false*.
+ 1. If _nx_ is *+0* and _ny_ is *-0*, return *false*.
+ 1. If _nx_ is *-0* and _ny_ is *+0*, return *false*.
+ 1. If _nx_ is *+∞*, return *false*.
+ 1. If _ny_ is *+∞*, return *true*.
+ 1. If _ny_ is *-∞*, return *false*.
+ 1. If _nx_ is *-∞*, return *true*.
+ 1. If the mathematical value of _nx_ is less than the mathematical value of _ny_ —note that these mathematical values are both finite and not both zero—return *true*. Otherwise, return *false*.
+
+
+
Step 5 differs from step 7 in the algorithm for the addition operator `+` () in using “and” instead of “or”.
+
+
+
The comparison of Strings uses a simple lexicographic ordering on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore String values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form. Also, note that for strings containing supplementary characters, lexicographic ordering on sequences of UTF-16 code unit values differs from that on sequences of code point values.
+
+
+
+
+
+
Abstract Equality Comparison
+
The comparison _x_ == _y_, where _x_ and _y_ are values, produces *true* or *false*. Such a comparison is performed as follows:
+
+ 1. ReturnIfAbrupt(_x_).
+ 1. ReturnIfAbrupt(_y_).
+ 1. If Type(_x_) is the same as Type(_y_), then
+ 1. Return the result of performing Strict Equality Comparison _x_ === _y_.
+ 1. If _x_ is *null* and _y_ is *undefined*, return *true*.
+ 1. If _x_ is *undefined* and _y_ is *null*, return *true*.
+ 1. If Type(_x_) is Number and Type(_y_) is String, return the result of the comparison _x_ == ToNumber(_y_).
+ 1. If Type(_x_) is String and Type(_y_) is Number, return the result of the comparison ToNumber(_x_) == _y_.
+ 1. If Type(_x_) is Boolean, return the result of the comparison ToNumber(_x_) == _y_.
+ 1. If Type(_y_) is Boolean, return the result of the comparison _x_ == ToNumber(_y_).
+ 1. If Type(_x_) is either String, Number, or Symbol and Type(_y_) is Object, return the result of the comparison _x_ == ToPrimitive(_y_).
+ 1. If Type(_x_) is Object and Type(_y_) is either String, Number, or Symbol, return the result of the comparison ToPrimitive(_x_) == _y_.
+ 1. Return *false*.
+
+
+
+
+
+
Strict Equality Comparison
+
The comparison _x_ === _y_, where _x_ and _y_ are values, produces *true* or *false*. Such a comparison is performed as follows:
+
+ 1. If Type(_x_) is different from Type(_y_), return *false*.
+ 1. If Type(_x_) is Number, then
+ 1. If _x_ is *NaN*, return *false*.
+ 1. If _y_ is *NaN*, return *false*.
+ 1. If _x_ is the same Number value as _y_, return *true*.
+ 1. If _x_ is *+0* and _y_ is *-0*, return *true*.
+ 1. If _x_ is *-0* and _y_ is *+0*, return *true*.
+ 1. Return *false*.
+ 1. Return SameValueNonNumber(_x_, _y_).
+
+
+
This algorithm differs from the SameValue Algorithm () in its treatment of signed zeroes and NaNs.
+
+
+
+
+
+
+
Operations on Objects
+
+
+
+
Get (_O_, _P_)
+
The abstract operation Get is used to retrieve the value of a specific property of an object. The operation is called with arguments _O_ and _P_ where _O_ is the object and _P_ is the property key. This abstract operation performs the following steps:
The abstract operation GetV is used to retrieve the value of a specific property of an ECMAScript language value. If the value is not an object, the property lookup is performed using a wrapper object appropriate for the type of the value. The operation is called with arguments _V_ and _P_ where _V_ is the value and _P_ is the property key. This abstract operation performs the following steps:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _O_ be ? ToObject(_V_).
+ 1. Return _O_.[[Get]](_P_, _V_).
+
+
+
+
+
+
Set (_O_, _P_, _V_, _Throw_)
+
The abstract operation Set is used to set the value of a specific property of an object. The operation is called with arguments _O_, _P_, _V_, and _Throw_ where _O_ is the object, _P_ is the property key, _V_ is the new value for the property and _Throw_ is a Boolean flag. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Assert: Type(_Throw_) is Boolean.
+ 1. Let _success_ be ? _O_.[[Set]](_P_, _V_, _O_).
+ 1. If _success_ is *false* and _Throw_ is *true*, throw a *TypeError* exception.
+ 1. Return _success_.
+
+
+
+
+
+
CreateDataProperty (_O_, _P_, _V_)
+
The abstract operation CreateDataProperty is used to create a new own property of an object. The operation is called with arguments _O_, _P_, and _V_ where _O_ is the object, _P_ is the property key, and _V_ is the value for the property. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _newDesc_ be the PropertyDescriptor{[[Value]]: _V_, [[Writable]]: *true*, [[Enumerable]]: *true*, [[Configurable]]: *true*}.
+ 1. Return _O_.[[DefineOwnProperty]](_P_, _newDesc_).
+
+
+
This abstract operation creates a property whose attributes are set to the same defaults used for properties created by the ECMAScript language assignment operator. Normally, the property will not already exist. If it does exist and is not configurable or if _O_ is not extensible, [[DefineOwnProperty]] will return *false*.
+
+
+
+
+
+
CreateMethodProperty (_O_, _P_, _V_)
+
The abstract operation CreateMethodProperty is used to create a new own property of an object. The operation is called with arguments _O_, _P_, and _V_ where _O_ is the object, _P_ is the property key, and _V_ is the value for the property. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _newDesc_ be the PropertyDescriptor{[[Value]]: _V_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}.
+ 1. Return _O_.[[DefineOwnProperty]](_P_, _newDesc_).
+
+
+
This abstract operation creates a property whose attributes are set to the same defaults used for built-in methods and methods defined using class declaration syntax. Normally, the property will not already exist. If it does exist and is not configurable or if _O_ is not extensible, [[DefineOwnProperty]] will return *false*.
+
+
+
+
+
+
CreateDataPropertyOrThrow (_O_, _P_, _V_)
+
The abstract operation CreateDataPropertyOrThrow is used to create a new own property of an object. It throws a *TypeError* exception if the requested property update cannot be performed. The operation is called with arguments _O_, _P_, and _V_ where _O_ is the object, _P_ is the property key, and _V_ is the value for the property. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _success_ be ? CreateDataProperty(_O_, _P_, _V_).
+ 1. If _success_ is *false*, throw a *TypeError* exception.
+ 1. Return _success_.
+
+
+
This abstract operation creates a property whose attributes are set to the same defaults used for properties created by the ECMAScript language assignment operator. Normally, the property will not already exist. If it does exist and is not configurable or if _O_ is not extensible, [[DefineOwnProperty]] will return *false* causing this operation to throw a *TypeError* exception.
+
+
+
+
+
+
DefinePropertyOrThrow (_O_, _P_, _desc_)
+
The abstract operation DefinePropertyOrThrow is used to call the [[DefineOwnProperty]] internal method of an object in a manner that will throw a *TypeError* exception if the requested property update cannot be performed. The operation is called with arguments _O_, _P_, and _desc_ where _O_ is the object, _P_ is the property key, and _desc_ is the Property Descriptor for the property. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _success_ be ? _O_.[[DefineOwnProperty]](_P_, _desc_).
+ 1. If _success_ is *false*, throw a *TypeError* exception.
+ 1. Return _success_.
+
+
+
+
+
+
DeletePropertyOrThrow (_O_, _P_)
+
The abstract operation DeletePropertyOrThrow is used to remove a specific own property of an object. It throws an exception if the property is not configurable. The operation is called with arguments _O_ and _P_ where _O_ is the object and _P_ is the property key. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _success_ be ? _O_.[[Delete]](_P_).
+ 1. If _success_ is *false*, throw a *TypeError* exception.
+ 1. Return _success_.
+
+
+
+
+
+
GetMethod (_O_, _P_)
+
The abstract operation GetMethod is used to get the value of a specific property of an object when the value of the property is expected to be a function. The operation is called with arguments _O_ and _P_ where _O_ is the object, _P_ is the property key. This abstract operation performs the following steps:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _func_ be ? GetV(_O_, _P_).
+ 1. If _func_ is either *undefined* or *null*, return *undefined*.
+ 1. If IsCallable(_func_) is *false*, throw a *TypeError* exception.
+ 1. Return _func_.
+
+
+
+
+
+
HasProperty (_O_, _P_)
+
The abstract operation HasProperty is used to determine whether an object has a property with the specified property key. The property may be either an own or inherited. A Boolean value is returned. The operation is called with arguments _O_ and _P_ where _O_ is the object and _P_ is the property key. This abstract operation performs the following steps:
The abstract operation HasOwnProperty is used to determine whether an object has an own property with the specified property key. A Boolean value is returned. The operation is called with arguments _O_ and _P_ where _O_ is the object and _P_ is the property key. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _desc_ be ? _O_.[[GetOwnProperty]](_P_).
+ 1. If _desc_ is *undefined*, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
Call(_F_, _V_, [_argumentsList_])
+
The abstract operation Call is used to call the [[Call]] internal method of a function object. The operation is called with arguments _F_, _V_ , and optionally _argumentsList_ where _F_ is the function object, _V_ is an ECMAScript language value that is the *this* value of the [[Call]], and _argumentsList_ is the value passed to the corresponding argument of the internal method. If _argumentsList_ is not present, an empty List is used as its value. This abstract operation performs the following steps:
+
+ 1. ReturnIfAbrupt(_F_).
+ 1. If _argumentsList_ was not passed, let _argumentsList_ be a new empty List.
+ 1. If IsCallable(_F_) is *false*, throw a *TypeError* exception.
+ 1. Return _F_.[[Call]](_V_, _argumentsList_).
+
+
+
+
+
+
Construct (_F_, [_argumentsList_], [_newTarget_])
+
The abstract operation Construct is used to call the [[Construct]] internal method of a function object. The operation is called with arguments _F_, and optionally _argumentsList_, and _newTarget_ where _F_ is the function object. _argumentsList_ and _newTarget_ are the values to be passed as the corresponding arguments of the internal method. If _argumentsList_ is not present, an empty List is used as its value. If _newTarget_ is not present, _F_ is used as its value. This abstract operation performs the following steps:
+
+ 1. If _newTarget_ was not passed, let _newTarget_ be _F_.
+ 1. If _argumentsList_ was not passed, let _argumentsList_ be a new empty List.
+ 1. Assert: IsConstructor(_F_) is *true*.
+ 1. Assert: IsConstructor(_newTarget_) is *true*.
+ 1. Return _F_.[[Construct]](_argumentsList_, _newTarget_).
+
+
+
If _newTarget_ is not passed, this operation is equivalent to: `new F(...argumentsList)`
+
+
+
+
+
+
SetIntegrityLevel (_O_, _level_)
+
The abstract operation SetIntegrityLevel is used to fix the set of own properties of an object. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: _level_ is either `"sealed"` or `"frozen"`.
+ 1. Let _status_ be ? _O_.[[PreventExtensions]]().
+ 1. If _status_ is *false*, return *false*.
+ 1. Let _keys_ be ? _O_.[[OwnPropertyKeys]]().
+ 1. If _level_ is `"sealed"`, then
+ 1. Repeat for each element _k_ of _keys_,
+ 1. Let _status_ be ? DefinePropertyOrThrow(_O_, _k_, PropertyDescriptor{ [[Configurable]]: *false*}).
+ 1. Else _level_ is `"frozen"`,
+ 1. Repeat for each element _k_ of _keys_,
+ 1. Let _currentDesc_ be ? _O_.[[GetOwnProperty]](_k_).
+ 1. If _currentDesc_ is not *undefined*, then
+ 1. If IsAccessorDescriptor(_currentDesc_) is *true*, then
+ 1. Let _desc_ be the PropertyDescriptor{[[Configurable]]: *false*}.
+ 1. Else,
+ 1. Let _desc_ be the PropertyDescriptor { [[Configurable]]: *false*, [[Writable]]: *false* }.
+ 1. Let _status_ be ? DefinePropertyOrThrow(_O_, _k_, _desc_).
+ 1. Return *true*.
+
+
+
+
+
+
TestIntegrityLevel (_O_, _level_)
+
The abstract operation TestIntegrityLevel is used to determine if the set of own properties of an object are fixed. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Assert: _level_ is either `"sealed"` or `"frozen"`.
+ 1. Let _status_ be ? IsExtensible(_O_).
+ 1. If _status_ is *true*, return *false*.
+ 1. NOTE If the object is extensible, none of its properties are examined.
+ 1. Let _keys_ be ? _O_.[[OwnPropertyKeys]]().
+ 1. Repeat for each element _k_ of _keys_,
+ 1. Let _currentDesc_ be ? _O_.[[GetOwnProperty]](_k_).
+ 1. If _currentDesc_ is not *undefined*, then
+ 1. If _currentDesc_.[[Configurable]] is *true*, return *false*.
+ 1. If _level_ is `"frozen"` and IsDataDescriptor(_currentDesc_) is *true*, then
+ 1. If _currentDesc_.[[Writable]] is *true*, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
CreateArrayFromList (_elements_)
+
The abstract operation CreateArrayFromList is used to create an Array object whose elements are provided by a List. This abstract operation performs the following steps:
+
+ 1. Assert: _elements_ is a List whose elements are all ECMAScript language values.
+ 1. Let _array_ be ArrayCreate(0) (see ).
+ 1. Let _n_ be 0.
+ 1. For each element _e_ of _elements_
+ 1. Let _status_ be CreateDataProperty(_array_, ToString(_n_), _e_).
+ 1. Assert: _status_ is *true*.
+ 1. Increment _n_ by 1.
+ 1. Return _array_.
+
+
+
+
+
+
The abstract operation CreateListFromArrayLike is used to create a List value whose elements are provided by the indexed properties of an array-like object, _obj_. The optional argument _elementTypes_ is a List containing the names of ECMAScript Language Types that are allowed for element values of the List that is created. This abstract operation performs the following steps:
+
+ 1. ReturnIfAbrupt(_obj_).
+ 1. If _elementTypes_ was not passed, let _elementTypes_ be (Undefined, Null, Boolean, String, Symbol, Number, Object).
+ 1. If Type(_obj_) is not Object, throw a *TypeError* exception.
+ 1. Let _len_ be ? ToLength(? Get(_obj_, `"length"`)).
+ 1. Let _list_ be an empty List.
+ 1. Let _index_ be 0.
+ 1. Repeat while _index_ < _len_
+ 1. Let _indexName_ be ToString(_index_).
+ 1. Let _next_ be ? Get(_obj_, _indexName_).
+ 1. If Type(_next_) is not an element of _elementTypes_, throw a *TypeError* exception.
+ 1. Append _next_ as the last element of _list_.
+ 1. Set _index_ to _index_ + 1.
+ 1. Return _list_.
+
+
+
+
+
+
Invoke(_O_,_P_, [_argumentsList_])
+
The abstract operation Invoke is used to call a method property of an object. The operation is called with arguments _O_, _P_ , and optionally _argumentsList_ where _O_ serves as both the lookup point for the property and the *this* value of the call, _P_ is the property key, and _argumentsList_ is the list of arguments values passed to the method. If _argumentsList_ is not present, an empty List is used as its value. This abstract operation performs the following steps:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. If _argumentsList_ was not passed, let _argumentsList_ be a new empty List.
+ 1. Let _func_ be GetV(_O_, _P_).
+ 1. Return Call(_func_, _O_, _argumentsList_).
+
+
+
+
+
+
OrdinaryHasInstance (_C_, _O_)
+
The abstract operation OrdinaryHasInstance implements the default algorithm for determining if an object _O_ inherits from the instance object inheritance path provided by constructor _C_. This abstract operation performs the following steps:
+
+ 1. If IsCallable(_C_) is *false*, return *false*.
+ 1. If _C_ has a [[BoundTargetFunction]] internal slot, then
+ 1. Let _BC_ be the value of _C_'s [[BoundTargetFunction]] internal slot.
+ 1. Return InstanceofOperator(_O_,_BC_) (see ).
+ 1. If Type(_O_) is not Object, return *false*.
+ 1. Let _P_ be ? Get(_C_, `"prototype"`).
+ 1. If Type(_P_) is not Object, throw a *TypeError* exception.
+ 1. Repeat
+ 1. Let _O_ be ? _O_.[[GetPrototypeOf]]().
+ 1. If _O_ is `null`, return *false*.
+ 1. If SameValue(_P_, _O_) is *true*, return *true*.
+
+
+
+
+
+
SpeciesConstructor ( _O_, _defaultConstructor_ )
+
The abstract operation SpeciesConstructor is used to retrieve the constructor that should be used to create new objects that are derived from the argument object _O_. The _defaultConstructor_ argument is the constructor to use if a constructor @@species property cannot be found starting from _O_. This abstract operation performs the following steps:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Let _C_ be ? Get(_O_, `"constructor"`).
+ 1. If _C_ is *undefined*, return _defaultConstructor_.
+ 1. If Type(_C_) is not Object, throw a *TypeError* exception.
+ 1. Let _S_ be ? Get(_C_, @@species).
+ 1. If _S_ is either *undefined* or *null*, return _defaultConstructor_.
+ 1. If IsConstructor(_S_) is *true*, return _S_.
+ 1. Throw a *TypeError* exception.
+
+
+
+
+
+
EnumerableOwnNames (_O_)
+
When the abstract operation EnumerableOwnNames is called with Object _O_ the following steps are taken:
+
+ 1. Assert: Type(_O_) is Object.
+ 1. Let _ownKeys_ be ? _O_.[[OwnPropertyKeys]]().
+ 1. Let _names_ be a new empty List.
+ 1. Repeat, for each element _key_ of _ownKeys_ in List order
+ 1. If Type(_key_) is String, then
+ 1. Let _desc_ be ? _O_.[[GetOwnProperty]](_key_).
+ 1. If _desc_ is not *undefined*, then
+ 1. If _desc_.[[Enumerable]] is *true*, append _key_ to _names_.
+ 1. If _O_.[[Enumerate]] is the ordinary object [[Enumerate]] internal method (), then
+ 1. Order the elements of _names_ so they are in the same relative order as would be produced by the Iterator that would be returned if the [[Enumerate]] internal method was invoked on _O_.
+ 1. Return _names_.
+
+
+
The order of elements in the returned list is the same as the enumeration order that is used by a for-in statement.
+
+
+
+
+
+
GetFunctionRealm ( _obj_ )
+
The abstract operation GetFunctionRealm with argument _obj_ performs the following steps:
+
+ 1. Assert: _obj_ is a callable object.
+ 1. If _obj_ has a [[Realm]] internal slot, then
+ 1. Return _obj_'s [[Realm]] internal slot.
+ 1. If _obj_ is a Bound Function exotic object, then
+ 1. Let _target_ be _obj_'s [[BoundTargetFunction]] internal slot.
+ 1. Return GetFunctionRealm(_target_).
+ 1. If _obj_ is a Proxy exotic object, then
+ 1. If the value of the [[ProxyHandler]] internal slot of _obj_ is *null*, throw a *TypeError* exception.
+ 1. Let _proxyTarget_ be the value of _obj_'s [[ProxyTarget]] internal slot.
+ 1. Return GetFunctionRealm(_proxyTarget_).
+ 1. Return the running execution context's Realm.
+
+
+
Step 5 will only be reached if _target_ is a non-standard exotic function object that does not have a [[Realm]] internal slot.
+
+
+
+
+
+
+
Operations on Iterator Objects
+
See Common Iteration Interfaces ().
+
+
+
+
GetIterator ( _obj_, _method_ )
+
The abstract operation GetIterator with argument _obj_ and optional argument _method_ performs the following steps:
+
+ 1. ReturnIfAbrupt(_obj_).
+ 1. If _method_ was not passed, then
+ 1. Let _method_ be GetMethod(_obj_, @@iterator).
+ 1. Let _iterator_ be ? Call(_method_,_obj_).
+ 1. If Type(_iterator_) is not Object, throw a *TypeError* exception.
+ 1. Return _iterator_.
+
+
+
+
+
+
IteratorNext ( _iterator_, _value_ )
+
The abstract operation IteratorNext with argument _iterator_ and optional argument _value_ performs the following steps:
+
+ 1. If _value_ was not passed, then
+ 1. Let _result_ be Invoke(_iterator_, `"next"`, « »).
+ 1. Else,
+ 1. Let _result_ be Invoke(_iterator_, `"next"`, « _value_ »).
+ 1. ReturnIfAbrupt(_result_).
+ 1. If Type(_result_) is not Object, throw a *TypeError* exception.
+ 1. Return _result_.
+
+
+
+
+
+
IteratorComplete ( _iterResult_ )
+
The abstract operation IteratorComplete with argument _iterResult_ performs the following steps:
The abstract operation IteratorStep with argument _iterator_ requests the next value from _iterator_ and returns either *false* indicating that the iterator has reached its end or the IteratorResult object if a next value is available. IteratorStep performs the following steps:
+
+ 1. Let _result_ be ? IteratorNext(_iterator_).
+ 1. Let _done_ be ? IteratorComplete(_result_).
+ 1. If _done_ is *true*, return *false*.
+ 1. Return _result_.
+
+
+
+
+
+
IteratorClose( _iterator_, _completion_ )
+
The abstract operation IteratorClose with arguments _iterator_ and _completion_ is used to notify an iterator that it should perform any actions it would normally perform when it has reached its completed state:
+
+ 1. Assert: Type(_iterator_) is Object.
+ 1. Assert: _completion_ is a Completion Record.
+ 1. Let _return_ be ? GetMethod(_iterator_, `"return"`).
+ 1. If _return_ is *undefined*, return Completion(_completion_).
+ 1. Let _innerResult_ be Call(_return_, _iterator_, « »).
+ 1. If _completion_.[[type]] is ~throw~, return Completion(_completion_).
+ 1. If _innerResult_.[[type]] is ~throw~, return Completion(_innerResult_).
+ 1. If Type(_innerResult_.[[value]]) is not Object, throw a *TypeError* exception.
+ 1. Return Completion(_completion_).
+
+
+
+
+
+
CreateIterResultObject ( _value_, _done_ )
+
The abstract operation CreateIterResultObject with arguments _value_ and _done_ creates an object that supports the IteratorResult interface by performing the following steps:
The abstract operation CreateListIterator with argument _list_ creates an Iterator () object whose next method returns the successive elements of _list_. It performs the following steps:
+
+ 1. Let _iterator_ be ObjectCreate(%IteratorPrototype%, « [[IteratorNext]], [[IteratedList]], [[ListIteratorNextIndex]] »).
+ 1. Set _iterator_'s [[IteratedList]] internal slot to _list_.
+ 1. Set _iterator_'s [[ListIteratorNextIndex]] internal slot to 0.
+ 1. Let _next_ be a new built-in function object as defined in ListIterator `next` ().
+ 1. Set _iterator_'s [[IteratorNext]] internal slot to _next_.
+ 1. Perform CreateMethodProperty(_iterator_, `"next"`, _next_).
+ 1. Return _iterator_.
+
+
+
+
+
ListIterator next( )
+
The ListIterator `next` method is a standard built-in function object (clause ) that performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _f_ be the active function object.
+ 1. If _O_ does not have a [[IteratorNext]] internal slot, throw a *TypeError* exception.
+ 1. Let _next_ be the value of the [[IteratorNext]] internal slot of _O_.
+ 1. If SameValue(_f_, _next_) is *false*, throw a *TypeError* exception.
+ 1. If _O_ does not have an [[IteratedList]] internal slot, throw a *TypeError* exception.
+ 1. Let _list_ be the value of the [[IteratedList]] internal slot of _O_.
+ 1. Let _index_ be the value of the [[ListIteratorNextIndex]] internal slot of _O_.
+ 1. Let _len_ be the number of elements of _list_.
+ 1. If _index_ ≥ _len_, then
+ 1. Return CreateIterResultObject(*undefined*, *true*).
+ 1. Set the value of the [[ListIteratorNextIndex]] internal slot of _O_ to _index_+1.
+ 1. Return CreateIterResultObject(_list_[_index_], *false*).
+
+
+
A ListIterator `next` method will throw an exception if applied to any object other than the one with which it was originally associated.
+
+
+
+
+
+
+
+
+
Executable Code and Execution Contexts
+
+
+
+
Lexical Environments
+
A Lexical Environment is a specification type used to define the association of |Identifier|s to specific variables and functions based upon the lexical nesting structure of ECMAScript code. A Lexical Environment consists of an Environment Record and a possibly null reference to an outer Lexical Environment. Usually a Lexical Environment is associated with some specific syntactic structure of ECMAScript code such as a |FunctionDeclaration|, a |BlockStatement|, or a |Catch| clause of a |TryStatement| and a new Lexical Environment is created each time such code is evaluated.
+
An Environment Record records the identifier bindings that are created within the scope of its associated Lexical Environment. It is referred to as the Lexical Environment's EnvironmentRecord
+
The outer environment reference is used to model the logical nesting of Lexical Environment values. The outer reference of a (inner) Lexical Environment is a reference to the Lexical Environment that logically surrounds the inner Lexical Environment. An outer Lexical Environment may, of course, have its own outer Lexical Environment. A Lexical Environment may serve as the outer environment for multiple inner Lexical Environments. For example, if a |FunctionDeclaration| contains two nested |FunctionDeclaration|s then the Lexical Environments of each of the nested functions will have as their outer Lexical Environment the Lexical Environment of the current evaluation of the surrounding function.
+
A global environment is a Lexical Environment which does not have an outer environment. The global environment's outer environment reference is *null*. A global environment's EnvironmentRecord may be prepopulated with identifier bindings and includes an associated global object whose properties provide some of the global environment's identifier bindings. As ECMAScript code is executed, additional properties may be added to the global object and the initial properties may be modified.
+
A module environment is a Lexical Environment that contains the bindings for the top level declarations of a |Module|. It also contains the bindings that are explicitly imported by the |Module|. The outer environment of a module environment is a global environment.
+
A function environment is a Lexical Environment that corresponds to the invocation of an ECMAScript function object. A function environment may establish a new `this` binding. A function environment also captures the state necessary to support `super` method invocations.
+
Lexical Environments and Environment Record values are purely specification mechanisms and need not correspond to any specific artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to directly access or manipulate such values.
+
+
+
+
Environment Records
+
There are two primary kinds of Environment Record values used in this specification: declarative Environment Records and object Environment Records. Declarative Environment Records are used to define the effect of ECMAScript language syntactic elements such as |FunctionDeclaration|s, |VariableDeclaration|s, and |Catch| clauses that directly associate identifier bindings with ECMAScript language values. Object Environment Records are used to define the effect of ECMAScript elements such as |WithStatement| that associate identifier bindings with the properties of some object. Global Environment Records and function Environment Records are specializations that are used for specifically for |Script| global declarations and for top-level declarations within functions.
+
For specification purposes Environment Record values are values of the Record specification type and can be thought of as existing in a simple object-oriented hierarchy where Environment Record is an abstract class with three concrete subclasses, declarative Environment Record, object Environment Record, and global Environment Record. Function Environment Records and module Environment Records are subclasses of declarative Environment Record. The abstract class includes the abstract specification methods defined in . These abstract methods have distinct concrete algorithms for each of the concrete subclasses.
+
+
+
+
+
+ Method
+
+
+ Purpose
+
+
+
+
+ HasBinding(N)
+
+
+ Determine if an Environment Record has a binding for the String value _N_. Return *true* if it does and *false* if it does not
+
+
+
+
+ CreateMutableBinding(N, D)
+
+
+ Create a new but uninitialized mutable binding in an Environment Record. The String value _N_ is the text of the bound name. If the optional Boolean argument _D_ is *true* the binding is may be subsequently deleted.
+
+
+
+
+ CreateImmutableBinding(N, S)
+
+
+ Create a new but uninitialized immutable binding in an Environment Record. The String value _N_ is the text of the bound name. If _S_ is *true* then attempts to access the value of the binding before it is initialized or set it after it has been initialized will always throw an exception, regardless of the strict mode setting of operations that reference that binding. _S_ is an optional parameter that defaults to *false*.
+
+
+
+
+ InitializeBinding(N,V)
+
+
+ Set the value of an already existing but uninitialized binding in an Environment Record. The String value _N_ is the text of the bound name. _V_ is the value for the binding and is a value of any ECMAScript language type.
+
+
+
+
+ SetMutableBinding(N,V, S)
+
+
+ Set the value of an already existing mutable binding in an Environment Record. The String value _N_ is the text of the bound name. _V_ is the value for the binding and may be a value of any ECMAScript language type. _S_ is a Boolean flag. If _S_ is *true* and the binding cannot be set throw a *TypeError* exception.
+
+
+
+
+ GetBindingValue(N,S)
+
+
+ Returns the value of an already existing binding from an Environment Record. The String value _N_ is the text of the bound name. _S_ is used to identify references originating in strict mode code or that otherwise require strict mode reference semantics. If _S_ is *true* and the binding does not exist throw a *ReferenceError* exception. If the binding exists but is uninitialized a *ReferenceError* is thrown, regardless of the value of _S_.
+
+
+
+
+ DeleteBinding(N)
+
+
+ Delete a binding from an Environment Record. The String value _N_ is the text of the bound name. If a binding for _N_ exists, remove the binding and return *true*. If the binding exists but cannot be removed return *false*. If the binding does not exist return *true*.
+
+
+
+
+ HasThisBinding()
+
+
+ Determine if an Environment Record establishes a `this` binding. Return *true* if it does and *false* if it does not.
+
+
+
+
+ HasSuperBinding()
+
+
+ Determine if an Environment Record establishes a `super` method binding. Return *true* if it does and *false* if it does not.
+
+
+
+
+ WithBaseObject ()
+
+
+ If this Environment Record is associated with a `with` statement, return the with object. Otherwise, return *undefined*.
+
+
+
+
+
+
+
+
+
Declarative Environment Records
+
Each declarative Environment Record is associated with an ECMAScript program scope containing variable, constant, let, class, module, import, and/or function declarations. A declarative Environment Record binds the set of identifiers defined by the declarations contained within its scope.
+
The behaviour of the concrete specification methods for declarative Environment Records is defined by the following algorithms.
+
+
+
+
HasBinding(_N_)
+
The concrete Environment Record method HasBinding for declarative Environment Records simply determines if the argument identifier is one of the identifiers bound by the record:
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. If _envRec_ has a binding for the name that is the value of _N_, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
CreateMutableBinding (_N_, _D_)
+
The concrete Environment Record method CreateMutableBinding for declarative Environment Records creates a new mutable binding for the name _N_ that is uninitialized. A binding must not already exist in this Environment Record for _N_. If Boolean argument _D_ is provided and has the value *true* the new binding is marked as being subject to deletion.
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ does not already have a binding for _N_.
+ 1. Create a mutable binding in _envRec_ for _N_ and record that it is uninitialized. If _D_ is *true* record that the newly created binding may be deleted by a subsequent DeleteBinding call.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
CreateImmutableBinding (_N_, _S_)
+
The concrete Environment Record method CreateImmutableBinding for declarative Environment Records creates a new immutable binding for the name _N_ that is uninitialized. A binding must not already exist in this Environment Record for _N_. If Boolean argument _S_ is provided and has the value *true* the new binding is marked as a strict binding.
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ does not already have a binding for _N_.
+ 1. Create an immutable binding in _envRec_ for _N_ and record that it is uninitialized. If _S_ is *true* record that the newly created binding is a strict binding.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
InitializeBinding (_N_,_V_)
+
The concrete Environment Record method InitializeBinding for declarative Environment Records is used to set the bound value of the current binding of the identifier whose name is the value of the argument _N_ to the value of argument _V_. An uninitialized binding for _N_ must already exist.
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ must have an uninitialized binding for _N_.
+ 1. Set the bound value for _N_ in _envRec_ to _V_.
+ 1. Record that the binding for _N_ in _envRec_ has been initialized.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
SetMutableBinding (_N_,_V_,_S_)
+
The concrete Environment Record method SetMutableBinding for declarative Environment Records attempts to change the bound value of the current binding of the identifier whose name is the value of the argument _N_ to the value of argument _V_. A binding for _N_ normally already exist, but in rare cases it may not. If the binding is an immutable binding, a *TypeError* is thrown if _S_ is *true*.
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. If _envRec_ does not have a binding for _N_, then
+ 1. If _S_ is *true*, throw a *ReferenceError* exception.
+ 1. Perform _envRec_.CreateMutableBinding(_N_, *true*).
+ 1. Perform _envRec_.InitializeBinding(_N_, _V_).
+ 1. Return NormalCompletion(~empty~).
+ 1. If the binding for _N_ in _envRec_ is a strict binding, let _S_ be *true*.
+ 1. If the binding for _N_ in _envRec_ has not yet been initialized, throw a *ReferenceError* exception.
+ 1. Else if the binding for _N_ in _envRec_ is a mutable binding, change its bound value to _V_.
+ 1. Else this must be an attempt to change the value of an immutable binding so if _S_ is *true*, throw a *TypeError* exception.
+ 1. Return NormalCompletion(~empty~).
+
+
+
An example of ECMAScript code that results in a missing binding at step 2 is:
+
function f(){eval("var x; x = (delete x, 0);")}
+
+
+
+
+
+
GetBindingValue(_N_,_S_)
+
The concrete Environment Record method GetBindingValue for declarative Environment Records simply returns the value of its bound identifier whose name is the value of the argument _N_. If the binding exists but is uninitialized a *ReferenceError* is thrown, regardless of the value of _S_.
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ has a binding for _N_.
+ 1. If the binding for _N_ in _envRec_ is an uninitialized binding, throw a *ReferenceError* exception.
+ 1. Return the value currently bound to _N_ in _envRec_.
+
+
+
+
+
+
DeleteBinding (_N_)
+
The concrete Environment Record method DeleteBinding for declarative Environment Records can only delete bindings that have been explicitly designated as being subject to deletion.
+
+ 1. Let _envRec_ be the declarative Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ has a binding for the name that is the value of _N_.
+ 1. If the binding for _N_ in _envRec_ cannot be deleted, return *false*.
+ 1. Remove the binding for _N_ from _envRec_.
+ 1. Return *true*.
+
+
+
+
+
+
HasThisBinding ()
+
Regular declarative Environment Records do not provide a `this` binding.
+
+ 1. Return *false*.
+
+
+
+
+
+
HasSuperBinding ()
+
Regular declarative Environment Records do not provide a `super` binding.
+
+ 1. Return *false*.
+
+
+
+
+
+
WithBaseObject()
+
Declarative Environment Records always return *undefined* as their WithBaseObject.
+
+ 1. Return *undefined*.
+
+
+
+
+
+
+
Object Environment Records
+
Each object Environment Record is associated with an object called its binding object. An object Environment Record binds the set of string identifier names that directly correspond to the property names of its binding object. Property keys that are not strings in the form of an |IdentifierName| are not included in the set of bound identifiers. Both own and inherited properties are included in the set regardless of the setting of their [[Enumerable]] attribute. Because properties can be dynamically added and deleted from objects, the set of identifiers bound by an object Environment Record may potentially change as a side-effect of any operation that adds or deletes properties. Any bindings that are created as a result of such a side-effect are considered to be a mutable binding even if the Writable attribute of the corresponding property has the value *false*. Immutable bindings do not exist for object Environment Records.
+
Object Environment Records created for `with` statements () can provide their binding object as an implicit *this* value for use in function calls. The capability is controlled by a _withEnvironment_ Boolean value that is associated with each object Environment Record. By default, the value of _withEnvironment_ is *false* for any object Environment Record.
+
The behaviour of the concrete specification methods for object Environment Records is defined by the following algorithms.
+
+
+
+
HasBinding(_N_)
+
The concrete Environment Record method HasBinding for object Environment Records determines if its associated binding object has a property whose name is the value of the argument _N_:
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. Let _bindings_ be the binding object for _envRec_.
+ 1. Let _foundBinding_ be ? HasProperty(_bindings_, _N_).
+ 1. If _foundBinding_ is *false*, return *false*.
+ 1. If the _withEnvironment_ flag of _envRec_ is *false*, return *true*.
+ 1. Let _unscopables_ be ? Get(_bindings_, @@unscopables).
+ 1. If Type(_unscopables_) is Object, then
+ 1. Let _blocked_ be ToBoolean(? Get(_unscopables_, _N_)).
+ 1. If _blocked_ is *true*, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
CreateMutableBinding (_N_, _D_)
+
The concrete Environment Record method CreateMutableBinding for object Environment Records creates in an Environment Record's associated binding object a property whose name is the String value and initializes it to the value *undefined*. If Boolean argument _D_ is provided and has the value *true* the new property's [[Configurable]] attribute is set to *true*; otherwise it is set to *false*.
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. Let _bindings_ be the binding object for _envRec_.
+ 1. If _D_ is *true*, let _configValue_ be *true*; otherwise let _configValue_ be *false*.
+ 1. Return DefinePropertyOrThrow(_bindings_, _N_, PropertyDescriptor{[[Value]]:*undefined*, [[Writable]]: *true*, [[Enumerable]]: *true* , [[Configurable]]: _configValue_}).
+
+
+
Normally _envRec_ will not have a binding for _N_ but if it does, the semantics of DefinePropertyOrThrow may result in an existing binding being replaced or shadowed or cause an abrupt completion to be returned.
+
+
+
+
+
+
CreateImmutableBinding (_N_, _S_)
+
The concrete Environment Record method CreateImmutableBinding is never used within this specification in association with object Environment Records.
+
+
+
+
+
InitializeBinding (_N_,_V_)
+
The concrete Environment Record method InitializeBinding for object Environment Records is used to set the bound value of the current binding of the identifier whose name is the value of the argument _N_ to the value of argument _V_. An uninitialized binding for _N_ must already exist.
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ must have an uninitialized binding for _N_.
+ 1. Record that the binding for _N_ in _envRec_ has been initialized.
+ 1. Return _envRec_.SetMutableBinding(_N_, _V_, *false*).
+
+
+
In this specification, all uses of CreateMutableBinding for object Environment Records are immediately followed by a call to InitializeBinding for the same name. Hence, implementations do not need to explicitly track the initialization state of individual object Environment Record bindings.
+
+
+
+
+
+
SetMutableBinding (_N_,_V_,_S_)
+
The concrete Environment Record method SetMutableBinding for object Environment Records attempts to set the value of the Environment Record's associated binding object's property whose name is the value of the argument _N_ to the value of argument _V_. A property named _N_ normally already exists but if it does not or is not currently writable, error handling is determined by the value of the Boolean argument _S_.
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. Let _bindings_ be the binding object for _envRec_.
+ 1. Return Set(_bindings_, _N_, _V_, _S_).
+
+
+
+
+
+
GetBindingValue(_N_,_S_)
+
The concrete Environment Record method GetBindingValue for object Environment Records returns the value of its associated binding object's property whose name is the String value of the argument identifier _N_. The property should already exist but if it does not the result depends upon the value of the _S_ argument:
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. Let _bindings_ be the binding object for _envRec_.
+ 1. Let _value_ be ? HasProperty(_bindings_, _N_).
+ 1. If _value_ is *false*, then
+ 1. If _S_ is *false*, return the value *undefined*; otherwise throw a *ReferenceError* exception.
+ 1. Return Get(_bindings_, _N_).
+
+
+
+
+
+
DeleteBinding (_N_)
+
The concrete Environment Record method DeleteBinding for object Environment Records can only delete bindings that correspond to properties of the environment object whose [[Configurable]] attribute have the value *true*.
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. Let _bindings_ be the binding object for _envRec_.
+ 1. Return _bindings_.[[Delete]](_N_).
+
+
+
+
+
+
HasThisBinding ()
+
Regular object Environment Records do not provide a `this` binding.
+
+ 1. Return *false*.
+
+
+
+
+
+
HasSuperBinding ()
+
Regular object Environment Records do not provide a `super` binding.
+
+ 1. Return *false*.
+
+
+
+
+
+
WithBaseObject()
+
Object Environment Records return *undefined* as their WithBaseObject unless their _withEnvironment_ flag is *true*.
+
+ 1. Let _envRec_ be the object Environment Record for which the method was invoked.
+ 1. If the _withEnvironment_ flag of _envRec_ is *true*, return the binding object for _envRec_.
+ 1. Otherwise, return *undefined*.
+
+
+
+
+
+
+
Function Environment Records
+
A function Environment Record is a declarative Environment Record that is used to represent the top-level scope of a function and, if the function is not an |ArrowFunction|, provides a `this` binding. If a function is not an |ArrowFunction| function and references `super`, its function Environment Record also contains the state that is used to perform `super` method invocations from within the function.
+
Function Environment Records have the additional state fields listed in .
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[thisValue]]
+
+
+ Any
+
+
+ This is the *this* value used for this invocation of the function.
+
+ If the value is `"lexical"`, this is an |ArrowFunction| and does not have a local this value.
+
+
+
+
+ [[FunctionObject]]
+
+
+ Object
+
+
+ The function Object whose invocation caused this Environment Record to be created.
+
+
+
+
+ [[HomeObject]]
+
+
+ Object | *undefined*
+
+
+ If the associated function has `super` property accesses and is not an |ArrowFunction|, [[HomeObject]] is the object that the function is bound to as a method. The default value for [[HomeObject]] is *undefined*.
+
+
+
+
+ [[NewTarget]]
+
+
+ Object | *undefined*
+
+
+ If this Environment Record was created by the [[Construct]] internal method, [[NewTarget]] is the value of the [[Construct]] _newTarget_ parameter. Otherwise, its value is *undefined*.
+
+
+
+
+
+
Function Environment Records support all of the declarative Environment Record methods listed in and share the same specifications for all of those methods except for HasThisBinding and HasSuperBinding. In addition, function Environment Records support the methods listed in :
+
+
+
+
+
+ Method
+
+
+ Purpose
+
+
+
+
+ BindThisValue(V)
+
+
+ Set the [[thisValue]] and record that it has been initialized.
+
+
+
+
+ GetThisBinding()
+
+
+ Return the value of this Environment Record's `this` binding. Throws a *ReferenceError* if the `this` binding has not been initialized.
+
+
+
+
+ GetSuperBase()
+
+
+ Return the object that is the base for `super` property accesses bound in this Environment Record. The object is derived from this Environment Record's [[HomeObject]] field. The value *undefined* indicates that `super` property accesses will produce runtime errors.
+
+
+
+
+
+
The behaviour of the additional concrete specification methods for function Environment Records is defined by the following algorithms:
+
+
+
+
BindThisValue(_V_)
+
+ 1. Let _envRec_ be the function Environment Record for which the method was invoked.
+ 1. Assert: _envRec_.[[thisBindingStatus]] is not `"lexical"`.
+ 1. If _envRec_.[[thisBindingStatus]] is `"initialized"`, throw a *ReferenceError* exception.
+ 1. Set _envRec_.[[thisValue]] to _V_.
+ 1. Set _envRec_.[[thisBindingStatus]] to `"initialized"`.
+ 1. Return _V_.
+
+
+
+
+
+
HasThisBinding ()
+
+ 1. Let _envRec_ be the function Environment Record for which the method was invoked.
+ 1. If _envRec_.[[thisBindingStatus]] is `"lexical"`, return *false*; otherwise, return *true*.
+
+
+
+
+
+
HasSuperBinding ()
+
+ 1. Let _envRec_ be the function Environment Record for which the method was invoked.
+ 1. If _envRec_.[[thisBindingStatus]] is `"lexical"`, return *false*.
+ 1. If _envRec_.[[HomeObject]] has the value *undefined*, return *false*; otherwise, return *true*.
+
+
+
+
+
+
GetThisBinding ()
+
+ 1. Let _envRec_ be the function Environment Record for which the method was invoked.
+ 1. Assert: _envRec_.[[thisBindingStatus]] is not `"lexical"`.
+ 1. If _envRec_.[[thisBindingStatus]] is `"uninitialized"`, throw a *ReferenceError* exception.
+ 1. Return _envRec_.[[thisValue]].
+
+
+
+
+
+
GetSuperBase ()
+
+ 1. Let _envRec_ be the function Environment Record for which the method was invoked.
+ 1. Let _home_ be the value of _envRec_.[[HomeObject]].
+ 1. If _home_ has the value *undefined*, return *undefined*.
+ 1. Assert: Type(_home_) is Object.
+ 1. Return _home_.[[GetPrototypeOf]]().
+
+
+
+
+
+
+
Global Environment Records
+
A global Environment Record is used to represent the outer most scope that is shared by all of the ECMAScript |Script| elements that are processed in a common Realm (). A global Environment Record provides the bindings for built-in globals (clause ), properties of the global object, and for all top-level declarations (, ) that occur within a |Script|.
+
A global Environment Record is logically a single record but it is specified as a composite encapsulating an object Environment Record and a declarative Environment Record. The object Environment Record has as its base object the global object of the associated Realm. This global object is the value returned by the global Environment Record's GetThisBinding concrete method. The object Environment Record component of a global Environment Record contains the bindings for all built-in globals (clause ) and all bindings introduced by a |FunctionDeclaration|, |GeneratorDeclaration|, or |VariableStatement| contained in global code. The bindings for all other ECMAScript declarations in global code are contained in the declarative Environment Record component of the global Environment Record.
+
Properties may be created directly on a global object. Hence, the object Environment Record component of a global Environment Record may contain both bindings created explicitly by |FunctionDeclaration|, |GeneratorDeclaration|, or |VariableDeclaration| declarations and bindings created implicitly as properties of the global object. In order to identify which bindings were explicitly created using declarations, a global Environment Record maintains a list of the names bound using its CreateGlobalVarBindings and CreateGlobalFunctionBindings concrete methods.
+
Global Environment Records have the additional fields listed in and the additional methods listed in .
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[ObjectRecord]]
+
+
+ Object Environment Record
+
+
+ Binding object is the global object. It contains global built-in bindings as well as |FunctionDeclaration|, |GeneratorDeclaration|, and |VariableDeclaration| bindings in global code for the associated Realm.
+
+
+
+
+ [[GlobalThisValue]]
+
+
+ Object
+
+
+ The value returned by `this` in global scope. Hosts may provide any ECMAScript Object value.
+
+
+
+
+ [[DeclarativeRecord]]
+
+
+ Declarative Environment Record
+
+
+ Contains bindings for all declarations in global code for the associated Realm code except for |FunctionDeclaration|, |GeneratorDeclaration|, and |VariableDeclaration| _bindings_.
+
+
+
+
+ [[VarNames]]
+
+
+ List of String
+
+
+ The string names bound by |FunctionDeclaration|, |GeneratorDeclaration|, and |VariableDeclaration| declarations in global code for the associated Realm.
+
+
+
+
+
+
+
+
+
+
+ Method
+
+
+ Purpose
+
+
+
+
+ GetThisBinding()
+
+
+ Return the value of this Environment Record's `this` binding.
+
+
+
+
+ HasVarDeclaration (N)
+
+
+ Determines if the argument identifier has a binding in this Environment Record that was created using a |VariableDeclaration|, |FunctionDeclaration|, or |GeneratorDeclaration|.
+
+
+
+
+ HasLexicalDeclaration (N)
+
+
+ Determines if the argument identifier has a binding in this Environment Record that was created using a lexical declaration such as a |LexicalDeclaration| or a |ClassDeclaration|.
+
+
+
+
+ HasRestrictedGlobalProperty (N)
+
+
+ Determines if the argument is the name of a global object property that may not be shadowed by a global lexically binding.
+
+
+
+
+ CanDeclareGlobalVar (N)
+
+
+ Determines if a corresponding CreateGlobalVarBinding call would succeed if called for the same argument _N_.
+
+
+
+
+ CanDeclareGlobalFunction (N)
+
+
+ Determines if a corresponding CreateGlobalFunctionBinding call would succeed if called for the same argument _N_.
+
+
+
+
+ CreateGlobalVarBinding(N, D)
+
+
+ Used to create and initialize to *undefined* a global `var` binding in the [[ObjectRecord]] component of a global Environment Record. The binding will be a mutable binding. The corresponding global object property will have attribute values appropriate for a `var`. The String value _N_ is the bound name. If _D_ is *true* the binding may be deleted. Logically equivalent to CreateMutableBinding followed by a SetMutableBinding but it allows var declarations to receive special treatment.
+
+
+
+
+ CreateGlobalFunctionBinding(N, V, D)
+
+
+ Create and initialize a global `function` binding in the [[ObjectRecord]] component of a global Environment Record. The binding will be a mutable binding. The corresponding global object property will have attribute values appropriate for a `function`. The String value _N_ is the bound name. _V_ is the initialization value. If the optional Boolean argument _D_ is *true* the binding is may be deleted. Logically equivalent to CreateMutableBinding followed by a SetMutableBinding but it allows function declarations to receive special treatment.
+
+
+
+
+
+
The behaviour of the concrete specification methods for global Environment Records is defined by the following algorithms.
+
+
+
+
HasBinding(_N_)
+
The concrete Environment Record method HasBinding for global Environment Records simply determines if the argument identifier is one of the identifiers bound by the record:
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, return *true*.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Return _ObjRec_.HasBinding(_N_).
+
+
+
+
+
+
CreateMutableBinding (_N_, _D_)
+
The concrete Environment Record method CreateMutableBinding for global Environment Records creates a new mutable binding for the name _N_ that is uninitialized. The binding is created in the associated DeclarativeRecord. A binding for _N_ must not already exist in the DeclarativeRecord. If Boolean argument _D_ is provided and has the value *true* the new binding is marked as being subject to deletion.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, throw a *TypeError* exception.
+ 1. Return _DclRec_.CreateMutableBinding(_N_, _D_).
+
+
+
+
+
+
CreateImmutableBinding (_N_, _S_)
+
The concrete Environment Record method CreateImmutableBinding for global Environment Records creates a new immutable binding for the name _N_ that is uninitialized. A binding must not already exist in this Environment Record for _N_. If Boolean argument _S_ is provided and has the value *true* the new binding is marked as a strict binding.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, throw a *TypeError* exception.
+ 1. Return _DclRec_.CreateImmutableBinding(_N_, _S_).
+
+
+
+
+
+
InitializeBinding (_N_,_V_)
+
The concrete Environment Record method InitializeBinding for global Environment Records is used to set the bound value of the current binding of the identifier whose name is the value of the argument _N_ to the value of argument _V_. An uninitialized binding for _N_ must already exist.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, then
+ 1. Return _DclRec_.InitializeBinding(_N_, _V_).
+ 1. Assert: If the binding exists it must be in the object Environment Record.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Return _ObjRec_.InitializeBinding(_N_, _V_).
+
+
+
+
+
+
SetMutableBinding (_N_,_V_,_S_)
+
The concrete Environment Record method SetMutableBinding for global Environment Records attempts to change the bound value of the current binding of the identifier whose name is the value of the argument _N_ to the value of argument _V_. If the binding is an immutable binding, a *TypeError* is thrown if _S_ is *true*. A property named _N_ normally already exists but if it does not or is not currently writable, error handling is determined by the value of the Boolean argument _S_.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, then
+ 1. Return _DclRec_.SetMutableBinding(_N_, _V_, _S_).
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Return _ObjRec_.SetMutableBinding(_N_, _V_, _S_).
+
+
+
+
+
+
GetBindingValue(_N_,_S_)
+
The concrete Environment Record method GetBindingValue for global Environment Records returns the value of its bound identifier whose name is the value of the argument _N_. If the binding is an uninitialized binding throw a *ReferenceError* exception. A property named _N_ normally already exists but if it does not or is not currently writable, error handling is determined by the value of the Boolean argument _S_.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, then
+ 1. Return _DclRec_.GetBindingValue(_N_, _S_).
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Return _ObjRec_.GetBindingValue(_N_, _S_).
+
+
+
+
+
+
DeleteBinding (_N_)
+
The concrete Environment Record method DeleteBinding for global Environment Records can only delete bindings that have been explicitly designated as being subject to deletion.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. If _DclRec_.HasBinding(_N_) is *true*, then
+ 1. Return _DclRec_.DeleteBinding(_N_).
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Let _globalObject_ be the binding object for _ObjRec_.
+ 1. Let _existingProp_ be ? HasOwnProperty(_globalObject_, _N_).
+ 1. If _existingProp_ is *true*, then
+ 1. Let _status_ be ? _ObjRec_.DeleteBinding(_N_).
+ 1. If _status_ is *true*, then
+ 1. Let _varNames_ be _envRec_.[[VarNames]].
+ 1. If _N_ is an element of _varNames_, remove that element from the _varNames_.
+ 1. Return _status_.
+ 1. Return *true*.
+
+
+
+
+
+
HasThisBinding ()
+
+ 1. Return *true*.
+
+
+
+
+
+
HasSuperBinding ()
+
+ 1. Return *false*.
+
+
+
+
+
+
WithBaseObject()
+
Global Environment Records always return *undefined* as their WithBaseObject.
+
+ 1. Return *undefined*.
+
+
+
+
+
+
GetThisBinding ()
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Return _envRec_.[[GlobalThisValue]].
+
+
+
+
+
+
HasVarDeclaration (_N_)
+
The concrete Environment Record method HasVarDeclaration for global Environment Records determines if the argument identifier has a binding in this record that was created using a |VariableStatement| or a |FunctionDeclaration|:
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _varDeclaredNames_ be _envRec_.[[VarNames]].
+ 1. If _varDeclaredNames_ contains the value of _N_, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
HasLexicalDeclaration (_N_)
+
The concrete Environment Record method HasLexicalDeclaration for global Environment Records determines if the argument identifier has a binding in this record that was created using a lexical declaration such as a |LexicalDeclaration| or a |ClassDeclaration|:
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _DclRec_ be _envRec_.[[DeclarativeRecord]].
+ 1. Return _DclRec_.HasBinding(_N_).
+
+
+
+
+
+
HasRestrictedGlobalProperty (_N_)
+
The concrete Environment Record method HasRestrictedGlobalProperty for global Environment Records determines if the argument identifier is the name of a property of the global object that must not be shadowed by a global lexically binding:
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Let _globalObject_ be the binding object for _ObjRec_.
+ 1. Let _existingProp_ be ? _globalObject_.[[GetOwnProperty]](_N_).
+ 1. If _existingProp_ is *undefined*, return *false*.
+ 1. If _existingProp_.[[Configurable]] is *true*, return *false*.
+ 1. Return *true*.
+
+
+
Properties may exist upon a global object that were directly created rather than being declared using a var or function declaration. A global lexical binding may not be created that has the same name as a non-configurable property of the global object. The global property `undefined` is an example of such a property.
+
+
+
+
+
+
CanDeclareGlobalVar (_N_)
+
The concrete Environment Record method CanDeclareGlobalVar for global Environment Records determines if a corresponding CreateGlobalVarBinding call would succeed if called for the same argument _N_. Redundant var declarations and var declarations for pre-existing global object properties are allowed.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Let _globalObject_ be the binding object for _ObjRec_.
+ 1. Let _hasProperty_ be ? HasOwnProperty(_globalObject_, _N_).
+ 1. If _hasProperty_ is *true*, return *true*.
+ 1. Return IsExtensible(_globalObject_).
+
+
+
+
+
+
CanDeclareGlobalFunction (_N_)
+
The concrete Environment Record method CanDeclareGlobalFunction for global Environment Records determines if a corresponding CreateGlobalFunctionBinding call would succeed if called for the same argument _N_.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Let _globalObject_ be the binding object for _ObjRec_.
+ 1. Let _existingProp_ be ? _globalObject_.[[GetOwnProperty]](_N_).
+ 1. If _existingProp_ is *undefined*, return IsExtensible(_globalObject_).
+ 1. If _existingProp_.[[Configurable]] is *true*, return *true*.
+ 1. If IsDataDescriptor(_existingProp_) is *true* and _existingProp_ has attribute values {[[Writable]]: *true*, [[Enumerable]]: *true*}, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
CreateGlobalVarBinding (_N_, _D_)
+
The concrete Environment Record method CreateGlobalVarBinding for global Environment Records creates and initializes a mutable binding in the associated object Environment Record and records the bound name in the associated [[VarNames]] List. If a binding already exists, it is reused and assumed to be initialized.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Let _globalObject_ be the binding object for _ObjRec_.
+ 1. Let _hasProperty_ be ? HasOwnProperty(_globalObject_, _N_).
+ 1. Let _extensible_ be ? IsExtensible(_globalObject_).
+ 1. If _hasProperty_ is *false* and _extensible_ is *true*, then
+ 1. Let _status_ be ? _ObjRec_.CreateMutableBinding(_N_, _D_).
+ 1. Let _status_ be ? _ObjRec_.InitializeBinding(_N_, *undefined*).
+ 1. Let _varDeclaredNames_ be _envRec_.[[VarNames]].
+ 1. If _varDeclaredNames_ does not contain the value of _N_, then
+ 1. Append _N_ to _varDeclaredNames_.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
CreateGlobalFunctionBinding (_N_, _V_, _D_)
+
The concrete Environment Record method CreateGlobalFunctionBinding for global Environment Records creates and initializes a mutable binding in the associated object Environment Record and records the bound name in the associated [[VarNames]] List. If a binding already exists, it is replaced.
+
+ 1. Let _envRec_ be the global Environment Record for which the method was invoked.
+ 1. Let _ObjRec_ be _envRec_.[[ObjectRecord]].
+ 1. Let _globalObject_ be the binding object for _ObjRec_.
+ 1. Let _existingProp_ be ? _globalObject_.[[GetOwnProperty]](_N_).
+ 1. If _existingProp_ is *undefined* or _existingProp_.[[Configurable]] is *true*, then
+ 1. Let _desc_ be the PropertyDescriptor{[[Value]]:_V_, [[Writable]]: *true*, [[Enumerable]]: *true* , [[Configurable]]: _D_}.
+ 1. Else,
+ 1. Let _desc_ be the PropertyDescriptor{[[Value]]:_V_ }.
+ 1. Let _status_ be ? DefinePropertyOrThrow(_globalObject_, _N_, _desc_).
+ 1. Let _status_ be Set(_globalObject_, _N_, _V_, *false*).
+ 1. Record that the binding for _N_ in _ObjRec_ has been initialized.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Let _varDeclaredNames_ be _envRec_.[[VarNames]].
+ 1. If _varDeclaredNames_ does not contain the value of _N_, then
+ 1. Append _N_ to _varDeclaredNames_.
+ 1. Return NormalCompletion(~empty~).
+
+
+
Global function declarations are always represented as own properties of the global object. If possible, an existing own property is reconfigured to have a standard set of attribute values. Steps 10-12 are equivalent to what calling the InitializeBinding concrete method would do and if _globalObject_ is a Proxy will produce the same sequence of Proxy trap calls.
+
+
+
+
+
+
+
Module Environment Records
+
A module Environment Record is a declarative Environment Record that is used to represent the outer scope of an ECMAScript |Module|. In additional to normal mutable and immutable bindings, module Environment Records also provide immutable import bindings which are bindings that provide indirect access to a target binding that exists in another Environment Record.
+
Module Environment Records support all of the declarative Environment Record methods listed in and share the same specifications for all of those methods except for GetBindingValue, DeleteBinding, HasThisBinding and GetThisBinding. In addition, module Environment Records support the methods listed in :
+
+
+
+
+
+ Method
+
+
+ Purpose
+
+
+
+
+ CreateImportBinding(N, M, N2 )
+
+
+ Create an immutable indirect binding in a module Environment Record. The String value _N_ is the text of the bound name. _M_ is a Module Record (see ), and _N2_ is a binding that exists in M's module Environment Record.
+
+
+
+
+ GetThisBinding()
+
+
+ Return the value of this Environment Record's `this` binding.
+
+
+
+
+
+
The behaviour of the additional concrete specification methods for module Environment Records are defined by the following algorithms:
+
+
+
+
GetBindingValue(_N_,_S_)
+
The concrete Environment Record method GetBindingValue for module Environment Records returns the value of its bound identifier whose name is the value of the argument _N_. However, if the binding is an indirect binding the value of the target binding is returned. If the binding exists but is uninitialized a *ReferenceError* is thrown, regardless of the value of _S_.
+
+ 1. Let _envRec_ be the module Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ has a binding for _N_.
+ 1. If the binding for _N_ is an indirect binding, then
+ 1. Let _M_ and _N2_ be the indirection values provided when this binding for _N_ was created.
+ 1. Let _targetEnv_ be _M_.[[Environment]].
+ 1. If _targetEnv_ is *undefined*, throw a *ReferenceError* exception.
+ 1. Let _targetER_ be _targetEnv_'s EnvironmentRecord.
+ 1. Return _targetER_.GetBindingValue(_N2_, _S_).
+ 1. If the binding for _N_ in _envRec_ is an uninitialized binding, throw a *ReferenceError* exception.
+ 1. Return the value currently bound to _N_ in _envRec_.
+
+
+
Because a |Module| is always strict mode code, calls to GetBindingValue should always pass *true* as the value of _S_.
+
+
+
+
+
+
DeleteBinding (_N_)
+
The concrete Environment Record method DeleteBinding for module Environment Records refuses to delete bindings.
+
+ 1. Let _envRec_ be the module Environment Record for which the method was invoked.
+ 1. If _envRec_ does not have a binding for the name that is the value of _N_, return *true*.
+ 1. Return *false*.
+
+
+
The bindings of a module Environment Record are not deletable.
+
+
+
+
+
+
HasThisBinding ()
+
Module Environment Records provide a `this` binding.
+
+ 1. Return *true*.
+
+
+
+
+
+
GetThisBinding ()
+
+ 1. Return *undefined*.
+
+
+
+
+
+
CreateImportBinding (_N_, _M_, _N2_)
+
The concrete Environment Record method CreateImportBinding for module Environment Records creates a new initialized immutable indirect binding for the name _N_. A binding must not already exist in this Environment Record for _N_. _M_ is a Module Record (see ), and _N2_ is the name of a binding that exists in M's module Environment Record. Accesses to the value of the new binding will indirectly access the bound value of the target binding.
+
+ 1. Let _envRec_ be the module Environment Record for which the method was invoked.
+ 1. Assert: _envRec_ does not already have a binding for _N_.
+ 1. Assert: _M_ is a Module Record.
+ 1. Assert: When _M_.[[Environment]] is instantiated it will have a direct binding for _N2_.
+ 1. Create an immutable indirect binding in _envRec_ for _N_ that references _M_ and _N2_ as its target binding and record that the binding is initialized.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
+
+
Lexical Environment Operations
+
The following abstract operations are used in this specification to operate upon lexical environments:
+
+
+
+
GetIdentifierReference (_lex_, _name_, _strict_)
+
The abstract operation GetIdentifierReference is called with a Lexical Environment _lex_, a String _name_, and a Boolean flag _strict_. The value of _lex_ may be *null*. When called, the following steps are performed:
+
+ 1. If _lex_ is the value *null*, then
+ 1. Return a value of type Reference whose base value is *undefined*, whose referenced name is _name_, and whose strict reference flag is _strict_.
+ 1. Let _envRec_ be _lex_'s EnvironmentRecord.
+ 1. Let _exists_ be ? _envRec_.HasBinding(_name_).
+ 1. If _exists_ is *true*, then
+ 1. Return a value of type Reference whose base value is _envRec_, whose referenced name is _name_, and whose strict reference flag is _strict_.
+ 1. Else,
+ 1. Let _outer_ be the value of _lex_'s outer environment reference.
+ 1. Return GetIdentifierReference(_outer_, _name_, _strict_).
+
+
+
+
+
+
NewDeclarativeEnvironment (_E_)
+
When the abstract operation NewDeclarativeEnvironment is called with a Lexical Environment as argument _E_ the following steps are performed:
+
+ 1. Let _env_ be a new Lexical Environment.
+ 1. Let _envRec_ be a new declarative Environment Record containing no bindings.
+ 1. Set _env_'s EnvironmentRecord to be _envRec_.
+ 1. Set the outer lexical environment reference of _env_ to _E_.
+ 1. Return _env_.
+
+
+
+
+
+
NewObjectEnvironment (_O_, _E_)
+
When the abstract operation NewObjectEnvironment is called with an Object _O_ and a Lexical Environment _E_ as arguments, the following steps are performed:
+
+ 1. Let _env_ be a new Lexical Environment.
+ 1. Let _envRec_ be a new object Environment Record containing _O_ as the binding object.
+ 1. Set _env_'s EnvironmentRecord to _envRec_.
+ 1. Set the outer lexical environment reference of _env_ to _E_.
+ 1. Return _env_.
+
+
+
+
+
+
NewFunctionEnvironment ( _F_, _newTarget_ )
+
When the abstract operation NewFunctionEnvironment is called with arguments _F_ and _newTarget_ the following steps are performed:
+
+ 1. Assert: _F_ is an ECMAScript function.
+ 1. Assert: Type(_newTarget_) is Undefined or Object.
+ 1. Let _env_ be a new Lexical Environment.
+ 1. Let _envRec_ be a new function Environment Record containing no bindings.
+ 1. Set _envRec_.[[FunctionObject]] to _F_.
+ 1. If _F_'s [[ThisMode]] internal slot is ~lexical~, set _envRec_.[[thisBindingStatus]] to `"lexical"`.
+ 1. Else, Set _envRec_.[[thisBindingStatus]] to `"uninitialized"`.
+ 1. Let _home_ be the value of _F_'s [[HomeObject]] internal slot.
+ 1. Set _envRec_.[[HomeObject]] to _home_.
+ 1. Set _envRec_.[[NewTarget]] to _newTarget_.
+ 1. Set _env_'s EnvironmentRecord to _envRec_.
+ 1. Set the outer lexical environment reference of _env_ to the value of _F_'s [[Environment]] internal slot.
+ 1. Return _env_.
+
+
+
+
+
+
NewGlobalEnvironment ( _G_, _thisValue_ )
+
When the abstract operation NewGlobalEnvironment is called with arguments _G_ and _thisValue_, the following steps are performed:
+
+ 1. Let _env_ be a new Lexical Environment.
+ 1. Let _objRec_ be a new object Environment Record containing _G_ as the binding object.
+ 1. Let _dclRec_ be a new declarative Environment Record containing no bindings.
+ 1. Let _globalRec_ be a new global Environment Record.
+ 1. Set _globalRec_.[[ObjectRecord]] to _objRec_.
+ 1. Set _globalRec_.[[GlobalThisValue]] to _thisValue_.
+ 1. Set _globalRec_.[[DeclarativeRecord]] to _dclRec_.
+ 1. Set _globalRec_.[[VarNames]] to a new empty List.
+ 1. Set _env_'s EnvironmentRecord to _globalRec_.
+ 1. Set the outer lexical environment reference of _env_ to *null*.
+ 1. Return _env_.
+
+
+
+
+
+
NewModuleEnvironment (_E_)
+
When the abstract operation NewModuleEnvironment is called with a Lexical Environment argument _E_ the following steps are performed:
+
+ 1. Let _env_ be a new Lexical Environment.
+ 1. Let _envRec_ be a new module Environment Record containing no bindings.
+ 1. Set _env_'s EnvironmentRecord to be _envRec_.
+ 1. Set the outer lexical environment reference of _env_ to _E_.
+ 1. Return _env_.
+
+
+
+
+
+
+
+
Code Realms
+
Before it is evaluated, all ECMAScript code must be associated with a Realm. Conceptually, a realm consists of a set of intrinsic objects, an ECMAScript global environment, all of the ECMAScript code that is loaded within the scope of that global environment, and other associated state and resources.
+
A Realm is specified as a Record with the fields specified in :
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[intrinsics]]
+
+
+ Record whose field names are intrinsic keys and whose values are objects
+
+
+ These are the intrinsic values used by code associated with this Realm
+
+
+
+
+ [[globalObject]]
+
+
+ Object
+
+
+ The global object for this Realm
+
+
+
+
+ [[globalEnv]]
+
+
+ Lexical Environment
+
+
+ The global environment for this Realm
+
+
+
+
+ [[templateMap]]
+
+
+ A List of Record { [[strings]]: List, [[array]]: Object}.
+
+
+ Template objects are canonicalized separately for each Realm using its [[templateMap]]. Each [[strings]] value is a List containing, in source text order, the raw String values of a |TemplateLiteral| that has been evaluated. The associated [[array]] value is the corresponding template object that is passed to a tag function.
+
+
+
+
+
+
An implementation may define other, implementation specific fields.
+
+
+
+
CreateRealm ( )
+
The abstract operation CreateRealm with no arguments performs the following steps:
+
+ 1. Let _realmRec_ be a new Record.
+ 1. Perform CreateIntrinsics(_realmRec_).
+ 1. Set _realmRec_.[[globalObject]] to *undefined*.
+ 1. Set _realmRec_.[[globalEnv]] to *undefined*.
+ 1. Set _realmRec_.[[templateMap]] to a new empty List.
+ 1. Return _realmRec_.
+
+
+
+
+
+
CreateIntrinsics ( _realmRec_ )
+
When the abstract operation CreateIntrinsics with argument _realmRec_ performs the following steps:
+
+ 1. Let _intrinsics_ be a new Record.
+ 1. Set _realmRec_.[[intrinsics]] to _intrinsics_.
+ 1. Let _objProto_ be ObjectCreate(*null*).
+ 1. Set _intrinsics_.[[%ObjectPrototype%]] to _objProto_.
+ 1. Let _throwerSteps_ be the algorithm steps specified in for the %ThrowTypeError% function.
+ 1. Let _thrower_ be CreateBuiltinFunction(_realmRec_, _throwerSteps_, *null*).
+ 1. Set _intrinsics_.[[%ThrowTypeError%]] to _thrower_.
+ 1. Let _noSteps_ be an empty sequence of algorithm steps.
+ 1. Let _funcProto_ be CreateBuiltinFunction(_realmRec_, _noSteps_, _objProto_).
+ 1. Set _intrinsics_.[[%FunctionPrototype%]] to _funcProto_.
+ 1. Call _thrower_.[[SetPrototypeOf]](_funcProto_).
+ 1. Perform AddRestrictedFunctionProperties(_funcProto_, _realmRec_).
+ 1. Set fields of _intrinsics_ with the values listed in that have not already been handled above. The field names are the names listed in column one of the table. The value of each field is a new object value fully and recursively populated with property values as defined by the specification of each object in clauses 18-26. All object property values are newly created object values. All values that are built-in function objects are created by performing CreateBuiltinFunction(_realmRec_, <steps>, <prototype>, <slots>) where <steps> is the definition of that function provided by this specification, <prototype> is the specified value of the function's [[Prototype]] internal slot and <slots> is a list of the names, if any, of the function's specified internal slots. The creation of the intrinsics and their properties must be ordered to avoid any dependencies upon objects that have not yet been created.
+ 1. Return _intrinsics_.
+
+
+
+
+
+
The abstract operation SetRealmGlobalObject with arguments _realmRec_, _globalObj_, and _thisValue_ performs the following steps:
+
+ 1. If _globalObj_ is *undefined*, then
+ 1. Let _intrinsics_ be _realmRec_.[[intrinsics]].
+ 1. Let _globalObj_ be ObjectCreate(_intrinsics_.[[%ObjectPrototype%]]).
+ 1. Assert: Type(_globalObj_) is Object.
+ 1. If _thisValue_ is *undefined*, let _thisValue_ be _globalObj_.
+ 1. Set _realmRec_.[[globalObject]] to _globalObj_.
+ 1. Let _newGlobalEnv_ be NewGlobalEnvironment(_globalObj_, _thisValue_).
+ 1. Set _realmRec_.[[globalEnv]] to _newGlobalEnv_.
+ 1. Return _realmRec_.
+
+
+
+
+
+
SetDefaultGlobalBindings ( _realmRec_ )
+
The abstract operation SetDefaultGlobalBindings with argument _realmRec_ performs the following steps:
+
+ 1. Let _global_ be _realmRec_.[[globalObject]].
+ 1. For each property of the Global Object specified in clause , do
+ 1. Let _name_ be the String value of the property name.
+ 1. Let _desc_ be the fully populated data property descriptor for the property containing the specified attributes for the property. For properties listed in , , or the value of the [[Value]] attribute is the corresponding intrinsic object from _realmRec_.
+ 1. Let _status_ be ? DefinePropertyOrThrow(_global_, _name_, _desc_).
+ 1. Return _global_.
+
+
+
+
+
+
+
Execution Contexts
+
An execution context is a specification device that is used to track the runtime evaluation of code by an ECMAScript implementation. At any point in time, there is at most one execution context that is actually executing code. This is known as the running execution context.
+
An execution context stack is used to track execution contexts. The running execution context is always the top element of this stack. A new execution context is created whenever control is transferred from the executable code associated with the currently running execution context to executable code that is not associated with that execution context. The newly created execution context is pushed onto the stack and becomes the running execution context.
+
An execution context contains whatever implementation specific state is necessary to track the execution progress of its associated code. Each execution context has at least the state components listed in .
+
+
+
+
+
+ Component
+
+
+ Purpose
+
+
+
+
+ code evaluation state
+
+
+ Any state needed to perform, suspend, and resume evaluation of the code associated with this execution context.
+
+
+
+
+ Function
+
+
+ If this execution context is evaluating the code of a function object, then the value of this component is that function object. If the context is evaluating the code of a |Script| or |Module|, the value is *null*.
+
+
+
+
+ Realm
+
+
+ The Realm from which associated code accesses ECMAScript resources.
+
+
+
+
+ ScriptOrModule
+
+
+ The Module Record or Script Record from which associated code originates. If there is no originating script or module, as is the case for the original execution context created in InitializeHostDefinedRealm, the value is *null*.
+
+
+
+
+
+
Evaluation of code by the running execution context may be suspended at various points defined within this specification. Once the running execution context has been suspended a different execution context may become the running execution context and commence evaluating its code. At some later time a suspended execution context may again become the running execution context and continue evaluating its code at the point where it had previously been suspended. Transition of the running execution context status among execution contexts usually occurs in stack-like last-in/first-out manner. However, some ECMAScript features require non-LIFO transitions of the running execution context.
+<<<<<<< HEAD
+
The value of the Realm component of the running execution context is also called the current Realm. The value of the Function component of the running execution context is also called the active function object.
+=======
+
The value of the Realm component of the running execution context is also called the current Realm. The value of the Function component of the running execution context is also called the active function object.
Execution contexts for ECMAScript code have the additional state components listed in .
+
+
+
+
+
+ Component
+
+
+ Purpose
+
+
+
+
+ LexicalEnvironment
+
+
+ Identifies the Lexical Environment used to resolve identifier references made by code within this execution context.
+
+
+
+
+ VariableEnvironment
+
+
+ Identifies the Lexical Environment whose EnvironmentRecord holds bindings created by |VariableStatement|s within this execution context.
+
+
+
+
+
+
The LexicalEnvironment and VariableEnvironment components of an execution context are always Lexical Environments. When an execution context is created its LexicalEnvironment and VariableEnvironment components initially have the same value.
+
Execution contexts representing the evaluation of generator objects have the additional state components listed in .
+
+
+
+
+
+ Component
+
+
+ Purpose
+
+
+
+
+ Generator
+
+
+ The GeneratorObject that this execution context is evaluating.
+
+
+
+
+
+
In most situations only the running execution context (the top of the execution context stack) is directly manipulated by algorithms within this specification. Hence when the terms “LexicalEnvironment”, and “VariableEnvironment” are used without qualification they are in reference to those components of the running execution context.
+
An execution context is purely a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation. It is impossible for ECMAScript code to directly access or observe an execution context.
+
+
+
+
ResolveBinding ( _name_, [_env_] )
+
The ResolveBinding abstract operation is used to determine the binding of _name_ passed as a String value. The optional argument _env_ can be used to explicitly provide the Lexical Environment that is to be searched for the binding. During execution of ECMAScript code, ResolveBinding is performed using the following algorithm:
+
+ 1. If _env_ was not passed or if _env_ is *undefined*, then
+ 1. Let _env_ be the running execution context's LexicalEnvironment.
+ 1. Assert: _env_ is a Lexical Environment.
+ 1. If the code matching the syntactic production that is being evaluated is contained in strict mode code, let _strict_ be *true*, else let _strict_ be *false*.
+ 1. Return GetIdentifierReference(_env_, _name_, _strict_ ).
+
+
+
The result of ResolveBinding is always a Reference value with its referenced name component equal to the _name_ argument.
+
+
+
+
+
+
GetThisEnvironment ( )
+
The abstract operation GetThisEnvironment finds the Environment Record that currently supplies the binding of the keyword `this`. GetThisEnvironment performs the following steps:
+
+ 1. Let _lex_ be the running execution context's LexicalEnvironment.
+ 1. Repeat
+ 1. Let _envRec_ be _lex_'s EnvironmentRecord.
+ 1. Let _exists_ be _envRec_.HasThisBinding().
+ 1. If _exists_ is *true*, return _envRec_.
+ 1. Let _outer_ be the value of _lex_'s outer environment reference.
+ 1. Let _lex_ be _outer_.
+
+
+
The loop in step 2 will always terminate because the list of environments always ends with the global environment which has a `this` binding.
+
+
+
+
+
+
ResolveThisBinding ( )
+
The abstract operation ResolveThisBinding determines the binding of the keyword `this` using the LexicalEnvironment of the running execution context. ResolveThisBinding performs the following steps:
+
+ 1. Let _envRec_ be GetThisEnvironment( ).
+ 1. Return _envRec_.GetThisBinding().
+
+
+
+
+
+
GetNewTarget ( )
+
The abstract operation GetNewTarget determines the NewTarget value using the LexicalEnvironment of the running execution context. GetNewTarget performs the following steps:
+
+ 1. Let _envRec_ be GetThisEnvironment( ).
+ 1. Assert: _envRec_ has a [[NewTarget]] field.
+ 1. Return _envRec_.[[NewTarget]].
+
+
+
+
+
+
GetGlobalObject ( )
+
The abstract operation GetGlobalObject returns the global object used by the currently running execution context. GetGlobalObject performs the following steps:
+
+ 1. Let _ctx_ be the running execution context.
+ 1. Let _currentRealm_ be _ctx_'s Realm.
+ 1. Return _currentRealm_.[[globalObject]].
+
+
+
+
+
+
+
Jobs and Job Queues
+
A Job is an abstract operation that initiates an ECMAScript computation when no other ECMAScript computation is currently in progress. A Job abstract operation may be defined to accept an arbitrary set of job parameters.
+
Execution of a Job can be initiated only when there is no running execution context and the execution context stack is empty. A PendingJob is a request for the future execution of a Job. A PendingJob is an internal Record whose fields are specified in . Once execution of a Job is initiated, the Job always executes to completion. No other Job may be initiated until the currently running Job completes. However, the currently running Job or external events may cause the enqueuing of additional PendingJobs that may be initiated sometime after completion of the currently running Job.
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[Job]]
+
+
+ The name of a Job abstract operation
+
+
+ This is the abstract operation that is performed when execution of this PendingJob is initiated. Jobs are abstract operations that use NextJob rather than Return to indicate that they have completed.
+
+
+
+
+ [[Arguments]]
+
+
+ A List
+
+
+ The List of argument values that are to be passed to [[Job]] when it is activated.
+
+
+
+
+ [[Realm]]
+
+
+ A Realm Record
+
+
+ The Realm for the initial execution context when this PendingJob is initiated.
+
+
+
+
+ [[ScriptOrModule]]
+
+
+ A Script Record or Module Record
+
+
+ The script or module for the initial execution context when this PendingJob is initiated.
+
+
+
+
+ [[HostDefined]]
+
+
+ Any, default value is *undefined*.
+
+
+ Field reserved for use by host environments that need to associate additional information with a pending Job.
+
+
+
+
+
+
A Job Queue is a FIFO queue of PendingJob records. Each Job Queue has a name and the full set of available Job Queues are defined by an ECMAScript implementation. Every ECMAScript implementation has at least the Job Queues defined in .
+
+
+
+
+
+ Name
+
+
+ Purpose
+
+
+
+
+ ScriptJobs
+
+
+ Jobs that validate and evaluate ECMAScript |Script| and |Module| source text. See clauses 10 and 15.
+
+
+
+
+ PromiseJobs
+
+
+ Jobs that are responses to the settlement of a Promise (see ).
+
+
+
+
+
+
A request for the future execution of a Job is made by enqueueing, on a Job Queue, a PendingJob record that includes a Job abstract operation name and any necessary argument values. When there is no running execution context and the execution context stack is empty, the ECMAScript implementation removes the first PendingJob from a Job Queue and uses the information contained in it to create an execution context and starts execution of the associated Job abstract operation.
+
The PendingJob records from a single Job Queue are always initiated in FIFO order. This specification does not define the order in which multiple Job Queues are serviced. An ECMAScript implementation may interweave the FIFO evaluation of the PendingJob records of a Job Queue with the evaluation of the PendingJob records of one or more other Job Queues. An implementation must define what occurs when there are no running execution context and all Job Queues are empty.
+
+
Typically an ECMAScript implementation will have its Job Queues pre-initialized with at least one PendingJob and one of those Jobs will be the first to be executed. An implementation might choose to free all resources and terminate if the current Job completes and all Job Queues are empty. Alternatively, it might choose to wait for a some implementation specific agent or mechanism to enqueue new PendingJob requests.
+
+
The following abstract operations are used to create and manage Jobs and Job Queues:
+
+
+
+
EnqueueJob (_queueName_, _job_, _arguments_)
+
The EnqueueJob abstract operation requires three arguments: _queueName_, _job_, and _arguments_. It performs the following steps:
+
+ 1. Assert: Type(_queueName_) is String and its value is the name of a Job Queue recognized by this implementation.
+ 1. Assert: _job_ is the name of a Job.
+ 1. Assert: _arguments_ is a List that has the same number of elements as the number of parameters required by _job_.
+ 1. Let _callerContext_ be the running execution context.
+ 1. Let _callerRealm_ be _callerContext_'s Realm.
+ 1. Let _callerScriptOrModule_ be _callerContext_'s ScriptOrModule.
+ 1. Let _pending_ be PendingJob{ [[Job]]: _job_, [[Arguments]]: _arguments_, [[Realm]]: _callerRealm_, [[ScriptOrModule]]: _callerScriptOrModule_, [[HostDefined]]: *undefined* }.
+ 1. Perform any implementation or host environment defined processing of _pending_. This may include modifying the [[HostDefined]] field or any other field of _pending_.
+ 1. Add _pending_ at the back of the Job Queue named by _queueName_.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
NextJob result
+
An algorithm step such as:
+
+ 1. NextJob _result_.
+
+
is used in Job abstract operations in place of:
+
+ 1. Return _result_.
+
+
Job abstract operations must not contain a Return step or a ReturnIfAbrupt step. The NextJob _result_ operation is equivalent to the following steps:
+
+ 1. If _result_ is an abrupt completion, perform implementation defined unhandled exception processing.
+ 1. Suspend the running execution context and remove it from the execution context stack.
+ 1. Assert: The execution context stack is now empty.
+ 1. Let _nextQueue_ be a non-empty Job Queue chosen in an implementation defined manner. If all Job Queues are empty, the result is implementation defined.
+ 1. Let _nextPending_ be the PendingJob record at the front of _nextQueue_. Remove that record from _nextQueue_.
+ 1. Let _newContext_ be a new execution context.
+ 1. Set _newContext_'s Function to *null*.
+ 1. Set _newContext_'s Realm to _nextPending_.[[Realm]].
+ 1. Set _newContext_'s ScriptOrModule to _nextPending_.[[ScriptOrModule]].
+ 1. Push _newContext_ onto the execution context stack; _newContext_ is now the running execution context.
+ 1. Perform any implementation or host environment defined job initialization using _nextPending_.
+ 1. Perform the abstract operation named by _nextPending_.[[Job]] using the elements of _nextPending_.[[Arguments]] as its arguments.
+
+
+
+
+
+
InitializeHostDefinedRealm( )
+
The abstract operation InitializeHostDefinedRealm performs the following steps:
+
+
+ 1. Let _realm_ be CreateRealm().
+ 1. Let _newContext_ be a new execution context.
+ 1. Set the Function of _newContext_ to *null*.
+ 1. Set the Realm of _newContext_ to _realm_.
+ 1. Set the ScriptOrModule of _newContext_ to *null*.
+ 1. Push _newContext_ onto the execution context stack; _newContext_ is now the running execution context.
+ 1. If the host requires use of an exotic object to serve as _realm_'s global object, let _global_ be such an object created in an implementation defined manner. Otherwise, let _global_ be *undefined*, indicating that an ordinary object should be created as the global object.
+ 1. If the host requires that the `this` binding in _realm_'s global scope return an object other than the global object, let _thisValue_ be such an object created in an implementation defined manner. Otherwise, let _thisValue_ be *undefined*, indicating that _realm_'s global `this` binding should be the global object.
+ 1. Perform SetRealmGlobalObject(_realm_, _global_, _thisValue_).
+ 1. Let _globalObj_ be ? SetDefaultGlobalBindings(_realm_).
+ 1. Create any implementation defined global object properties on _globalObj_.
+ 1. In an implementation dependent manner, obtain the ECMAScript source texts (see clause ) and any associated host-defined values for zero or more ECMAScript scripts and/or ECMAScript modules. For each such _sourceText_ and _hostDefined_,
+ 1. If _sourceText_ is the source code of a script, then
+ 1. Perform EnqueueJob(`"ScriptJobs"`, ScriptEvaluationJob, « _sourceText_, _hostDefined_ »).
+ 1. Else _sourceText_ is the source code of a module,
+ 1. Perform EnqueueJob(`"ScriptJobs"`, TopLevelModuleEvaluationJob, « _sourceText_, _hostDefined_ »).
+ 1. NextJob NormalCompletion(*undefined*).
+
+
+
+
+
+
+
Ordinary and Exotic Objects Behaviours
+
+
+
+
Ordinary Object Internal Methods and Internal Slots
+
All ordinary objects have an internal slot called [[Prototype]]. The value of this internal slot is either *null* or an object and is used for implementing inheritance. Data properties of the [[Prototype]] object are inherited (are visible as properties of the child object) for the purposes of get access, but not for set access. Accessor properties are inherited for both get access and set access.
+
Every ordinary object has a Boolean-valued [[Extensible]] internal slot that controls whether or not properties may be added to the object. If the value of the [[Extensible]] internal slot is *false* then additional properties may not be added to the object. In addition, if [[Extensible]] is *false* the value of the [[Prototype]] internal slot of the object may not be modified. Once the value of an object's [[Extensible]] internal slot has been set to *false* it may not be subsequently changed to *true*.
+
In the following algorithm descriptions, assume _O_ is an ordinary object, _P_ is a property key value, _V_ is any ECMAScript language value, and _Desc_ is a Property Descriptor record.
+
+
+
+
[[GetPrototypeOf]] ( )
+
When the [[GetPrototypeOf]] internal method of _O_ is called the following steps are taken:
+
+ 1. Return the value of the [[Prototype]] internal slot of _O_.
+
+
+
+
+
+
[[SetPrototypeOf]] (_V_)
+
When the [[SetPrototypeOf]] internal method of _O_ is called with argument _V_ the following steps are taken:
+
+ 1. Assert: Either Type(_V_) is Object or Type(_V_) is Null.
+ 1. Let _extensible_ be the value of the [[Extensible]] internal slot of _O_.
+ 1. Let _current_ be the value of the [[Prototype]] internal slot of _O_.
+ 1. If SameValue(_V_, _current_), return *true*.
+ 1. If _extensible_ is *false*, return *false*.
+ 1. Let _p_ be _V_.
+ 1. Let _done_ be *false*.
+ 1. Repeat while _done_ is *false*,
+ 1. If _p_ is *null*, let _done_ be *true*.
+ 1. Else, if SameValue(_p_, _O_) is *true*, return *false*.
+ 1. Else,
+ 1. If the [[GetPrototypeOf]] internal method of _p_ is not the ordinary object internal method defined in , let _done_ be *true*.
+ 1. Else, let _p_ be the value of _p_'s [[Prototype]] internal slot.
+ 1. Set the value of the [[Prototype]] internal slot of _O_ to _V_.
+ 1. Return *true*.
+
+
+
The loop in step 8 guarantees that there will be no circularities in any prototype chain that only includes objects that use the ordinary object definitions for [[GetPrototypeOf]] and [[SetPrototypeOf]].
+
+
+
+
+
+
[[IsExtensible]] ( )
+
When the [[IsExtensible]] internal method of _O_ is called the following steps are taken:
+
+ 1. Return the value of the [[Extensible]] internal slot of _O_.
+
+
+
+
+
+
[[PreventExtensions]] ( )
+
When the [[PreventExtensions]] internal method of _O_ is called the following steps are taken:
+
+ 1. Set the value of the [[Extensible]] internal slot of _O_ to *false*.
+ 1. Return *true*.
+
+
+
+
+
+
[[GetOwnProperty]] (_P_)
+
When the [[GetOwnProperty]] internal method of _O_ is called with property key _P_, the following steps are taken:
When the abstract operation OrdinaryGetOwnProperty is called with Object _O_ and with property key _P_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. If _O_ does not have an own property with key _P_, return *undefined*.
+ 1. Let _D_ be a newly created Property Descriptor with no fields.
+ 1. Let _X_ be _O_'s own property whose key is _P_.
+ 1. If _X_ is a data property, then
+ 1. Set _D_.[[Value]] to the value of _X_'s [[Value]] attribute.
+ 1. Set _D_.[[Writable]] to the value of _X_'s [[Writable]] attribute.
+ 1. Else _X_ is an accessor property, so
+ 1. Set _D_.[[Get]] to the value of _X_'s [[Get]] attribute.
+ 1. Set _D_.[[Set]] to the value of _X_'s [[Set]] attribute.
+ 1. Set _D_.[[Enumerable]] to the value of _X_'s [[Enumerable]] attribute.
+ 1. Set _D_.[[Configurable]] to the value of _X_'s [[Configurable]] attribute.
+ 1. Return _D_.
+
+
+
+
+
+
+
[[DefineOwnProperty]] (_P_, _Desc_)
+
When the [[DefineOwnProperty]] internal method of _O_ is called with property key _P_ and Property Descriptor _Desc_, the following steps are taken:
When the abstract operation OrdinaryDefineOwnProperty is called with Object _O_, property key _P_, and Property Descriptor _Desc_ the following steps are taken:
+
+ 1. Let _current_ be ? _O_.[[GetOwnProperty]](_P_).
+ 1. Let _extensible_ be the value of the [[Extensible]] internal slot of _O_.
+ 1. Return ValidateAndApplyPropertyDescriptor(_O_, _P_, _extensible_, _Desc_, _current_).
+
+
+
+
+
+
When the abstract operation IsCompatiblePropertyDescriptor is called with Boolean value _Extensible_, and Property Descriptors _Desc_, and _Current_ the following steps are taken:
When the abstract operation ValidateAndApplyPropertyDescriptor is called with Object _O_, property key _P_, Boolean value _extensible_, and Property Descriptors _Desc_, and _current_ the following steps are taken:
+
This algorithm contains steps that test various fields of the Property Descriptor _Desc_ for specific values. The fields that are tested in this manner need not actually exist in _Desc_. If a field is absent then its value is considered to be *false*.
+
+
If *undefined* is passed as the _O_ argument only validation is performed and no object updates are performed.
+
+
+ 1. Assert: If _O_ is not *undefined* then IsPropertyKey(_P_) is *true*.
+ 1. If _current_ is *undefined*, then
+ 1. If _extensible_ is *false*, return *false*.
+ 1. Assert: _extensible_ is *true*.
+ 1. If IsGenericDescriptor(_Desc_) or IsDataDescriptor(_Desc_) is *true*, then
+ 1. If _O_ is not *undefined*, create an own data property named _P_ of object _O_ whose [[Value]], [[Writable]], [[Enumerable]] and [[Configurable]] attribute values are described by _Desc_. If the value of an attribute field of _Desc_ is absent, the attribute of the newly created property is set to its default value.
+ 1. Else _Desc_ must be an accessor Property Descriptor,
+ 1. If _O_ is not *undefined*, create an own accessor property named _P_ of object _O_ whose [[Get]], [[Set]], [[Enumerable]] and [[Configurable]] attribute values are described by _Desc_. If the value of an attribute field of _Desc_ is absent, the attribute of the newly created property is set to its default value.
+ 1. Return *true*.
+ 1. Return *true*, if every field in _Desc_ is absent.
+ 1. Return *true*, if every field in _Desc_ also occurs in _current_ and the value of every field in _Desc_ is the same value as the corresponding field in _current_ when compared using the SameValue algorithm.
+ 1. If the [[Configurable]] field of _current_ is *false*, then
+ 1. Return *false*, if the [[Configurable]] field of _Desc_ is *true*.
+ 1. Return *false*, if the [[Enumerable]] field of _Desc_ is present and the [[Enumerable]] fields of _current_ and _Desc_ are the Boolean negation of each other.
+ 1. If IsGenericDescriptor(_Desc_) is *true*, no further validation is required.
+ 1. Else if IsDataDescriptor(_current_) and IsDataDescriptor(_Desc_) have different results, then
+ 1. Return *false*, if the [[Configurable]] field of _current_ is *false*.
+ 1. If IsDataDescriptor(_current_) is *true*, then
+ 1. If _O_ is not *undefined*, convert the property named _P_ of object _O_ from a data property to an accessor property. Preserve the existing values of the converted property's [[Configurable]] and [[Enumerable]] attributes and set the rest of the property's attributes to their default values.
+ 1. Else,
+ 1. If _O_ is not *undefined*, convert the property named _P_ of object _O_ from an accessor property to a data property. Preserve the existing values of the converted property's [[Configurable]] and [[Enumerable]] attributes and set the rest of the property's attributes to their default values.
+ 1. Else if IsDataDescriptor(_current_) and IsDataDescriptor(_Desc_) are both *true*, then
+ 1. If the [[Configurable]] field of _current_ is *false*, then
+ 1. Return *false*, if the [[Writable]] field of _current_ is *false* and the [[Writable]] field of _Desc_ is *true*.
+ 1. If the [[Writable]] field of _current_ is *false*, then
+ 1. Return *false*, if the [[Value]] field of _Desc_ is present and SameValue(_Desc_.[[Value]], _current_.[[Value]]) is *false*.
+ 1. Else the [[Configurable]] field of _current_ is *true*, so any change is acceptable.
+ 1. Else IsAccessorDescriptor(_current_) and IsAccessorDescriptor(_Desc_) are both *true*,
+ 1. If the [[Configurable]] field of _current_ is *false*, then
+ 1. Return *false*, if the [[Set]] field of _Desc_ is present and SameValue(_Desc_.[[Set]], _current_.[[Set]]) is *false*.
+ 1. Return *false*, if the [[Get]] field of _Desc_ is present and SameValue(_Desc_.[[Get]], _current_.[[Get]]) is *false*.
+ 1. If _O_ is not *undefined*, then
+ 1. For each field of _Desc_ that is present, set the corresponding attribute of the property named _P_ of object _O_ to the value of the field.
+ 1. Return *true*.
+
+
+
Step 8.b allows any field of _Desc_ to be different from the corresponding field of _current_ if _current_'s [[Configurable]] field is *true*. This even permits changing the [[Value]] of a property whose [[Writable]] attribute is *false*. This is allowed because a *true* [[Configurable]] attribute would permit an equivalent sequence of calls where [[Writable]] is first set to *true*, a new [[Value]] is set, and then [[Writable]] is set to *false*.
+
+
+
+
+
+
+
[[HasProperty]](_P_)
+
When the [[HasProperty]] internal method of _O_ is called with property key _P_, the following steps are taken:
When the abstract operation OrdinaryHasProperty is called with Object _O_ and with property key _P_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _hasOwn_ be OrdinaryGetOwnProperty(_O_, _P_).
+ 1. If _hasOwn_ is not *undefined*, return *true*.
+ 1. Let _parent_ be ? _O_.[[GetPrototypeOf]]().
+ 1. If _parent_ is not *null*, then
+ 1. Return _parent_.[[HasProperty]](_P_).
+ 1. Return *false*.
+
+
+
+
+
+
+
[[Get]] (_P_, _Receiver_)
+
When the [[Get]] internal method of _O_ is called with property key _P_ and ECMAScript language value _Receiver_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _desc_ be ? _O_.[[GetOwnProperty]](_P_).
+ 1. If _desc_ is *undefined*, then
+ 1. Let _parent_ be ? _O_.[[GetPrototypeOf]]().
+ 1. If _parent_ is *null*, return *undefined*.
+ 1. Return _parent_.[[Get]](_P_, _Receiver_).
+ 1. If IsDataDescriptor(_desc_) is *true*, return _desc_.[[Value]].
+ 1. Otherwise, IsAccessorDescriptor(_desc_) must be *true* so, let _getter_ be _desc_.[[Get]].
+ 1. If _getter_ is *undefined*, return *undefined*.
+ 1. Return Call(_getter_, _Receiver_).
+
+
+
+
+
+
[[Set]] ( _P_, _V_, _Receiver_)
+
When the [[Set]] internal method of _O_ is called with property key _P_, value _V_, and ECMAScript language value _Receiver_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _ownDesc_ be ? _O_.[[GetOwnProperty]](_P_).
+ 1. If _ownDesc_ is *undefined*, then
+ 1. Let _parent_ be ? _O_.[[GetPrototypeOf]]().
+ 1. If _parent_ is not *null*, then
+ 1. Return _parent_.[[Set]](_P_, _V_, _Receiver_).
+ 1. Else,
+ 1. Let _ownDesc_ be the PropertyDescriptor{[[Value]]: *undefined*, [[Writable]]: *true*, [[Enumerable]]: *true*, [[Configurable]]: *true*}.
+ 1. If IsDataDescriptor(_ownDesc_) is *true*, then
+ 1. If _ownDesc_.[[Writable]] is *false*, return *false*.
+ 1. If Type(_Receiver_) is not Object, return *false*.
+ 1. Let _existingDescriptor_ be ? _Receiver_.[[GetOwnProperty]](_P_).
+ 1. If _existingDescriptor_ is not *undefined*, then
+ 1. If IsAccessorDescriptor(_existingDescriptor_) is *true*, return *false*.
+ 1. If _existingDescriptor_.[[Writable]] is *false*, return *false*.
+ 1. Let _valueDesc_ be the PropertyDescriptor{[[Value]]: _V_}.
+ 1. Return _Receiver_.[[DefineOwnProperty]](_P_, _valueDesc_).
+ 1. Else _Receiver_ does not currently have a property _P_,
+ 1. Return CreateDataProperty(_Receiver_, _P_, _V_).
+ 1. Assert: IsAccessorDescriptor(_ownDesc_) is *true*.
+ 1. Let _setter_ be _ownDesc_.[[Set]].
+ 1. If _setter_ is *undefined*, return *false*.
+ 1. Let _setterResult_ be ? Call(_setter_, _Receiver_, « _V_ »).
+ 1. Return *true*.
+
+
+
+
+
+
[[Delete]] (_P_)
+
When the [[Delete]] internal method of _O_ is called with property key _P_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _desc_ be ? _O_.[[GetOwnProperty]](_P_).
+ 1. If _desc_ is *undefined*, return *true*.
+ 1. If _desc_.[[Configurable]] is *true*, then
+ 1. Remove the own property with name _P_ from _O_.
+ 1. Return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
[[Enumerate]] ()
+
When the [[Enumerate]] internal method of _O_ is called the following steps are taken:
+
+ 1. Return an Iterator object () whose `next` method iterates over all the String-valued keys of enumerable properties of _O_. The Iterator object must inherit from %IteratorPrototype% (). The mechanics and order of enumerating the properties is not specified but must conform to the rules specified below.
+
+
The iterator's `next` method processes object properties to determine whether the property key should be returned as an iterator value. Returned property keys do not include keys that are Symbols. Properties of the target object may be deleted during enumeration. A property that is deleted before it is processed by the iterator's `next` method is ignored. If new properties are added to the target object during enumeration, the newly added properties are not guaranteed to be processed in the active enumeration. A property name will be returned by the iterator's `next` method at most once in any enumeration.
+
Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively; but a property of a prototype is not processed if it has the same name as a property that has already been processed by the iterator's `next` method. The values of [[Enumerable]] attributes are not considered when determining if a property of a prototype object has already been processed. The enumerable property names of prototype objects must be obtained as if by invoking the prototype object's [[Enumerate]] internal method. [[Enumerate]] must obtain the own property keys of the target object as if by calling its [[OwnPropertyKeys]] internal method. Property attributes of the target object must be obtained as if by calling its [[GetOwnProperty]] internal method.
+
+
The following is an informative definition of an ECMAScript generator function that conforms to these rules:
+
+function* enumerate(obj) {
+ let visited = new Set;
+ for (let key of Reflect.ownKeys(obj)) {
+ if (typeof key === "string") {
+ let desc = Reflect.getOwnPropertyDescriptor(obj,key);
+ if (desc) {
+ visited.add(key);
+ if (desc.enumerable) yield key;
+ }
+ }
+}
+let proto = Reflect.getPrototypeOf(obj)
+if (proto === null) return;
+for (let protoName of Reflect.enumerate(proto)) {
+ if (!visited.has(protoName)) yield protoName;
+ }
+}
+
+
+
+
+
+
+
[[OwnPropertyKeys]] ( )
+
When the [[OwnPropertyKeys]] internal method of _O_ is called the following steps are taken:
+
+ 1. Let _keys_ be a new empty List.
+ 1. For each own property key _P_ of _O_ that is an integer index, in ascending numeric index order
+ 1. Add _P_ as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ that is a String but is not an integer index, in ascending chronological order of property creation
+ 1. Add _P_ as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ that is a Symbol, in ascending chronological order of property creation
+ 1. Add _P_ as the last element of _keys_.
+ 1. Return _keys_.
+
+
+
+
+
+
ObjectCreate(_proto_, _internalSlotsList_)
+
The abstract operation ObjectCreate with argument _proto_ (an object or null) is used to specify the runtime creation of new ordinary objects. The optional argument _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. If the list is not provided, an empty List is used. This abstract operation performs the following steps:
+
+ 1. If _internalSlotsList_ was not provided, let _internalSlotsList_ be an empty List.
+ 1. Let _obj_ be a newly created object with an internal slot for each name in _internalSlotsList_.
+ 1. Set _obj_'s essential internal methods to the default ordinary object definitions specified in .
+ 1. Set the [[Prototype]] internal slot of _obj_ to _proto_.
+ 1. Set the [[Extensible]] internal slot of _obj_ to *true*.
+ 1. Return _obj_.
+
+
+
+
+
+
The abstract operation OrdinaryCreateFromConstructor creates an ordinary object whose [[Prototype]] value is retrieved from a constructor's `prototype` property, if it exists. Otherwise the intrinsic named by _intrinsicDefaultProto_ is used for [[Prototype]]. The optional _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. If the list is not provided, an empty List is used. This abstract operation performs the following steps:
+
+ 1. Assert: _intrinsicDefaultProto_ is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
+ 1. Let _proto_ be ? GetPrototypeFromConstructor(_constructor_, _intrinsicDefaultProto_).
+ 1. Return ObjectCreate(_proto_, _internalSlotsList_).
+
+
+
+
+
+
The abstract operation GetPrototypeFromConstructor determines the [[Prototype]] value that should be used to create an object corresponding to a specific constructor. The value is retrieved from the constructor's `prototype` property, if it exists. Otherwise the intrinsic named by _intrinsicDefaultProto_ is used for [[Prototype]]. This abstract operation performs the following steps:
+
+ 1. Assert: _intrinsicDefaultProto_ is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
+ 1. Assert: IsCallable(_constructor_) is *true*.
+ 1. Let _proto_ be ? Get(_constructor_, `"prototype"`).
+ 1. If Type(_proto_) is not Object, then
+ 1. Let _realm_ be ? GetFunctionRealm(_constructor_).
+ 1. Let _proto_ be _realm_'s intrinsic object named _intrinsicDefaultProto_.
+ 1. Return _proto_.
+
+
+
If _constructor_ does not supply a [[Prototype]] value, the default value that is used is obtained from the Code Realm of the _constructor_ function rather than from the running execution context.
+
+
+
+
+
+
+
ECMAScript Function Objects
+
ECMAScript function objects encapsulate parameterized ECMAScript code closed over a lexical environment and support the dynamic evaluation of that code. An ECMAScript function object is an ordinary object and has the same internal slots and the same internal methods as other ordinary objects. The code of an ECMAScript function object may be either strict mode code () or non-strict mode code. An ECMAScript function object whose code is strict mode code is called a strict function. One whose code is not strict mode code is called a non-strict function.
+
ECMAScript function objects have the additional internal slots listed in .
+
+
+
+
+
+ Internal Slot
+
+
+ Type
+
+
+ Description
+
+
+
+
+ [[Environment]]
+
+
+ Lexical Environment
+
+
+ The Lexical Environment that the function was closed over. Used as the outer environment when evaluating the code of the function.
+
+
+
+
+ [[FormalParameters]]
+
+
+ Parse Node
+
+
+ The root parse node of the source text that defines the function's formal parameter list.
+
+
+
+
+ [[FunctionKind]]
+
+
+ String
+
+
+ Either `"normal"`, `"classConstructor"` or `"generator"`.
+
+
+
+
+ [[ECMAScriptCode]]
+
+
+ Parse Node
+
+
+ The root parse node of the source text that defines the function's body.
+
+
+
+
+ [[ConstructorKind]]
+
+
+ String
+
+
+ Either `"base"` or `"derived"`.
+
+
+
+
+ [[Realm]]
+
+
+ Realm Record
+
+
+ The Code Realm in which the function was created and which provides any intrinsic objects that are accessed when evaluating the function.
+
+
+
+
+ [[ScriptOrModule]]
+
+
+ Script Record or Module Record
+
+
+ The script or module in which the function was created.
+
+
+
+
+ [[ThisMode]]
+
+
+ (lexical, strict, global)
+
+
+ Defines how `this` references are interpreted within the formal parameters and code body of the function. ~lexical~ means that `this` refers to the *this* value of a lexically enclosing function. ~strict~ means that the *this* value is used exactly as provided by an invocation of the function. ~global~ means that a *this* value of *undefined* is interpreted as a reference to the global object.
+
+
+
+
+ [[Strict]]
+
+
+ Boolean
+
+
+ *true* if this is a strict mode function, *false* if this is not a strict mode function.
+
+
+
+
+ [[HomeObject]]
+
+
+ Object
+
+
+ If the function uses `super`, this is the object whose [[GetPrototypeOf]] provides the object where `super` property lookups begin.
+
+
+
+
+
+
All ECMAScript function objects have the [[Call]] internal method defined here. ECMAScript functions that are also constructors in addition have the [[Construct]] internal method.
+
+
+
+
[[Call]] ( _thisArgument_, _argumentsList_)
+
The [[Call]] internal method for an ECMAScript function object _F_ is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values. The following steps are taken:
+
+ 1. Assert: _F_ is an ECMAScript function object.
+ 1. If _F_'s [[FunctionKind]] internal slot is `"classConstructor"`, throw a *TypeError* exception.
+ 1. Let _callerContext_ be the running execution context.
+ 1. Let _calleeContext_ be PrepareForOrdinaryCall(_F_, *undefined*).
+ 1. Assert: _calleeContext_ is now the running execution context.
+ 1. Perform OrdinaryCallBindThis(_F_, _calleeContext_, _thisArgument_).
+ 1. Let _result_ be OrdinaryCallEvaluateBody(_F_, _argumentsList_).
+ 1. Remove _calleeContext_ from the execution context stack and restore _callerContext_ as the running execution context.
+ 1. If _result_.[[type]] is ~return~, return NormalCompletion(_result_.[[value]]).
+ 1. ReturnIfAbrupt(_result_).
+ 1. Return NormalCompletion(*undefined*).
+
+
+
When _calleeContext_ is removed from the execution context stack in step 8 it must not be destroyed if it is suspended and retained for later resumption by an accessible generator object.
+
+
+
+
+
PrepareForOrdinaryCall( _F_, _newTarget_ )
+
When the abstract operation PrepareForOrdinaryCall is called with function object _F_ and ECMAScript language value _newTarget_, the following steps are taken:
+
+ 1. Assert: Type(_newTarget_) is Undefined or Object.
+ 1. Let _callerContext_ be the running execution context.
+ 1. Let _calleeContext_ be a new ECMAScript code execution context.
+ 1. Set the Function of _calleeContext_ to _F_.
+ 1. Let _calleeRealm_ be the value of _F_'s [[Realm]] internal slot.
+ 1. Set the Realm of _calleeContext_ to _calleeRealm_.
+ 1. Set the ScriptOrModule of _calleeContext_ to the value of _F_'s [[ScriptOrModule]] internal slot.
+ 1. Let _localEnv_ be NewFunctionEnvironment(_F_, _newTarget_).
+ 1. Set the LexicalEnvironment of _calleeContext_ to _localEnv_.
+ 1. Set the VariableEnvironment of _calleeContext_ to _localEnv_.
+ 1. If _callerContext_ is not already suspended, Suspend _callerContext_.
+ 1. Push _calleeContext_ onto the execution context stack; _calleeContext_ is now the running execution context.
+ 1. NOTE Any exception objects produced after this point are associated with _calleeRealm_.
+ 1. Return _calleeContext_.
+
+
+
+
+
+
When the abstract operation OrdinaryCallBindThis is called with function object _F_, execution context _calleeContext_, and ECMAScript value _thisArgument_ the following steps are taken:
+
+ 1. Let _thisMode_ be the value of _F_'s [[ThisMode]] internal slot.
+ 1. If _thisMode_ is ~lexical~, return NormalCompletion(*undefined*).
+ 1. Let _calleeRealm_ be the value of _F_'s [[Realm]] internal slot.
+ 1. Let _localEnv_ be the LexicalEnvironment of _calleeContext_.
+ 1. If _thisMode_ is ~strict~, let _thisValue_ be _thisArgument_.
+ 1. Else,
+ 1. If _thisArgument_ is *null* or *undefined*, then
+ 1. Let _thisValue_ be _calleeRealm_.[[globalEnv]].[[GlobalThisValue]].
+ 1. Else,
+ 1. Let _thisValue_ be ToObject(_thisArgument_).
+ 1. Assert: _thisValue_ is not an abrupt completion.
+ 1. NOTE ToObject produces wrapper objects using _calleeRealm_.
+ 1. Let _envRec_ be _localEnv_'s EnvironmentRecord.
+ 1. Assert: The next step never returns an abrupt completion because _envRec_.[[thisBindingStatus]] is not `"uninitialized"`.
+ 1. Return _envRec_.BindThisValue(_thisValue_).
+
+
+
+
+
+
OrdinaryCallEvaluateBody ( _F_, _argumentsList_ )
+
When the abstract operation OrdinaryCallEvaluateBody is called with function object _F_ and List _argumentsList_ the following steps are taken:
+
+ 1. Let _status_ be ? FunctionDeclarationInstantiation(_F_, _argumentsList_).
+ 1. Return the result of EvaluateBody of the parsed code that is the value of _F_'s [[ECMAScriptCode]] internal slot passing _F_ as the argument.
+
+
+
+
+
+
+
[[Construct]] ( _argumentsList_, _newTarget_)
+
The [[Construct]] internal method for an ECMAScript Function object _F_ is called with parameters _argumentsList_ and _newTarget_. _argumentsList_ is a possibly empty List of ECMAScript language values. The following steps are taken:
+
+ 1. Assert: _F_ is an ECMAScript function object.
+ 1. Assert: Type(_newTarget_) is Object.
+ 1. Let _callerContext_ be the running execution context.
+ 1. Let _kind_ be _F_'s [[ConstructorKind]] internal slot.
+ 1. If _kind_ is `"base"`, then
+ 1. Let _thisArgument_ be ? OrdinaryCreateFromConstructor(_newTarget_, `"%ObjectPrototype%"`).
+ 1. Let _calleeContext_ be PrepareForOrdinaryCall(_F_, _newTarget_).
+ 1. Assert: _calleeContext_ is now the running execution context.
+ 1. If _kind_ is `"base"`, perform OrdinaryCallBindThis(_F_, _calleeContext_, _thisArgument_).
+ 1. Let _constructorEnv_ be the LexicalEnvironment of _calleeContext_.
+ 1. Let _envRec_ be _constructorEnv_'s EnvironmentRecord.
+ 1. Let _result_ be OrdinaryCallEvaluateBody(_F_, _argumentsList_).
+ 1. Remove _calleeContext_ from the execution context stack and restore _callerContext_ as the running execution context.
+ 1. If _result_.[[type]] is ~return~, then
+ 1. If Type(_result_.[[value]]) is Object, return NormalCompletion(_result_.[[value]]).
+ 1. If _kind_ is `"base"`, return NormalCompletion(_thisArgument_).
+ 1. If _result_.[[value]] is not *undefined*, throw a *TypeError* exception.
+ 1. Else, ReturnIfAbrupt(_result_).
+ 1. Return _envRec_.GetThisBinding().
+
+
+
+
+
+
The abstract operation FunctionAllocate requires the three arguments _functionPrototype_, _strict_ and _functionKind_. FunctionAllocate performs the following steps:
+
+ 1. Assert: Type(_functionPrototype_) is Object.
+ 1. Assert: _functionKind_ is either `"normal"`, `"non-constructor"` or `"generator"`.
+ 1. If _functionKind_ is `"normal"`, let _needsConstruct_ be *true*.
+ 1. Else, let _needsConstruct_ be *false*.
+ 1. If _functionKind_ is `"non-constructor"`, let _functionKind_ be `"normal"`.
+ 1. Let _F_ be a newly created ECMAScript function object with the internal slots listed in . All of those internal slots are initialized to *undefined*.
+ 1. Set _F_'s essential internal methods to the default ordinary object definitions specified in .
+ 1. Set _F_'s [[Call]] internal method to the definition specified in .
+ 1. If _needsConstruct_ is *true*, then
+ 1. Set _F_'s [[Construct]] internal method to the definition specified in .
+ 1. Set the [[ConstructorKind]] internal slot of _F_ to `"base"`.
+ 1. Set the [[Strict]] internal slot of _F_ to _strict_.
+ 1. Set the [[FunctionKind]] internal slot of _F_ to _functionKind_.
+ 1. Set the [[Prototype]] internal slot of _F_ to _functionPrototype_.
+ 1. Set the [[Extensible]] internal slot of _F_ to *true*.
+ 1. Set the [[Realm]] internal slot of _F_ to the running execution context's Realm.
+ 1. Return _F_.
+
+
+
+
+
+
The abstract operation FunctionInitialize requires the arguments: a function object _F_, _kind_ which is one of (Normal, Method, Arrow), a parameter list production specified by _ParameterList_, a body production specified by _Body_, a Lexical Environment specified by _Scope_. FunctionInitialize performs the following steps:
+
+ 1. Assert: _F_ is an extensible object that does not have a `length` own property.
+ 1. Let _len_ be the ExpectedArgumentCount of _ParameterList_.
+ 1. Let _status_ be DefinePropertyOrThrow(_F_, `"length"`, PropertyDescriptor{[[Value]]: _len_, [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Let _Strict_ be the value of the [[Strict]] internal slot of _F_.
+ 1. Set the [[Environment]] internal slot of _F_ to the value of _Scope_.
+ 1. Set the [[FormalParameters]] internal slot of _F_ to _ParameterList_ .
+ 1. Set the [[ECMAScriptCode]] internal slot of _F_ to _Body_.
+ 1. If the active function object is *null*, set the [[ScriptOrModule]] internal slot of _F_ to the running execution context's ScriptOrModule.
+ 1. Otherwise, set the [[ScriptOrModule]] internal slot of _F_ to the value of the active function object's [[ScriptOrModule]] internal slot.
+ 1. If _kind_ is ~Arrow~, set the [[ThisMode]] internal slot of _F_ to ~lexical~.
+ 1. Else if _Strict_ is *true*, set the [[ThisMode]] internal slot of _F_ to ~strict~.
+ 1. Else set the [[ThisMode]] internal slot of _F_ to ~global~.
+ 1. Return _F_.
+
+
+
+
+
+
The abstract operation FunctionCreate requires the arguments: _kind_ which is one of (Normal, Method, Arrow), a parameter list production specified by _ParameterList_, a body production specified by _Body_, a Lexical Environment specified by _Scope_, a Boolean flag _Strict_, and optionally, an object _prototype_. FunctionCreate performs the following steps:
+
+ 1. If the _prototype_ argument was not passed, then
+ 1. Let _prototype_ be the intrinsic object %FunctionPrototype%.
+ 1. If _kind_ is not ~Normal~, let _allocKind_ be `"non-constructor"`.
+ 1. Else let _allocKind_ be `"normal"`.
+ 1. Let _F_ be FunctionAllocate(_prototype_, _Strict_, _allocKind_).
+ 1. Return FunctionInitialize(_F_, _kind_, _ParameterList_, _Body_, _Scope_).
+
+
+
+
+
+
The abstract operation GeneratorFunctionCreate requires the arguments: _kind_ which is one of (Normal, Method), a parameter list production specified by _ParameterList_, a body production specified by _Body_, a Lexical Environment specified by _Scope_, and a Boolean flag _Strict_. GeneratorFunctionCreate performs the following steps:
+
+ 1. Let _functionPrototype_ be the intrinsic object %Generator%.
+ 1. Let _F_ be FunctionAllocate(_functionPrototype_, _Strict_, `"generator"`).
+ 1. Return FunctionInitialize(_F_, _kind_, _ParameterList_, _Body_, _Scope_).
+
+
+
+
+
+
AddRestrictedFunctionProperties ( _F_, _realm_ )
+
The abstract operation AddRestrictedFunctionProperties is called with a function object _F_ and Realm Record _realm_ as its argument. It performs the following steps:
+
+ 1. Assert: _realm_.[[intrinsics]].[[%ThrowTypeError%]] exists and has been initialized.
+ 1. Let _thrower_ be _realm_.[[intrinsics]].[[%ThrowTypeError%]].
+ 1. Let _status_ be DefinePropertyOrThrow(_F_, `"caller"`, PropertyDescriptor {[[Get]]: _thrower_, [[Set]]: _thrower_, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return DefinePropertyOrThrow(_F_ , `"arguments"`, PropertyDescriptor {[[Get]]: _thrower_, [[Set]]: _thrower_, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Assert: The above returned value is not an abrupt completion.
+
+
+
+
+
%ThrowTypeError% ( )
+
The %ThrowTypeError% intrinsic is an anonymous built-in function object that is defined once for each Realm. When %ThrowTypeError% is called it performs the following steps:
+
+ 1. Throw a *TypeError* exception.
+
+
The value of the [[Extensible]] internal slot of a %ThrowTypeError% function is *false*.
+
The `length` property of a %ThrowTypeError% function has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
The abstract operation MakeConstructor requires a Function argument _F_ and optionally, a Boolean _writablePrototype_ and an object _prototype_. If _prototype_ is provided it is assumed to already contain, if needed, a `"constructor"` property whose value is _F_. This operation converts _F_ into a constructor by performing the following steps:
+
+ 1. Assert: _F_ is an ECMAScript function object.
+ 1. Assert: _F_ has a [[Construct]] internal method.
+ 1. Assert: _F_ is an extensible object that does not have a `prototype` own property.
+ 1. If the _writablePrototype_ argument was not provided, let _writablePrototype_ be *true*.
+ 1. If the _prototype_ argument was not provided, then
+ 1. Let _prototype_ be ObjectCreate(%ObjectPrototype%).
+ 1. Let _status_ be DefinePropertyOrThrow(_prototype_, `"constructor"`, PropertyDescriptor{[[Value]]: _F_, [[Writable]]: _writablePrototype_, [[Enumerable]]: *false*, [[Configurable]]: *true* }).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Let _status_ be DefinePropertyOrThrow(_F_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: _writablePrototype_, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return NormalCompletion(*undefined*).
+
+
+
+
+
+
MakeClassConstructor ( _F_)
+
The abstract operation MakeClassConstructor with argument _F_ performs the following steps:
+
+ 1. Assert: _F_ is an ECMAScript function object.
+ 1. Assert: _F_'s [[FunctionKind]] internal slot is `"normal"`.
+ 1. Set _F_'s [[FunctionKind]] internal slot to `"classConstructor"`.
+ 1. Return NormalCompletion(*undefined*).
+
+
+
+
+
+
MakeMethod ( _F_, _homeObject_)
+
The abstract operation MakeMethod with arguments _F_ and _homeObject_ configures _F_ as a method by performing the following steps:
+
+ 1. Assert: _F_ is an ECMAScript function object.
+ 1. Assert: Type(_homeObject_ ) is Object.
+ 1. Set the [[HomeObject]] internal slot of _F_ to _homeObject_.
+ 1. Return NormalCompletion(*undefined*).
+
+
+
+
+
+
SetFunctionName (_F_, _name_, _prefix_)
+
The abstract operation SetFunctionName requires a Function argument _F_, a String or Symbol argument _name_ and optionally a String argument _prefix_. This operation adds a `name` property to _F_ by performing the following steps:
+
+ 1. Assert: _F_ is an extensible object that does not have a `name` own property.
+ 1. Assert: Type(_name_) is either Symbol or String.
+ 1. Assert: If _prefix_ was passed then Type(_prefix_) is String.
+ 1. If Type(_name_) is Symbol, then
+ 1. Let _description_ be _name_'s [[Description]] value.
+ 1. If _description_ is *undefined*, let _name_ be the empty String.
+ 1. Else, let _name_ be the concatenation of `"["`, _description_, and `"]"`.
+ 1. If _prefix_ was passed, then
+ 1. Let _name_ be the concatenation of _prefix_, code unit 0x0020 (SPACE), and _name_.
+ 1. Return DefinePropertyOrThrow(_F_, `"name"`, PropertyDescriptor{[[Value]]: _name_, [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Assert: the result is never an abrupt completion.
+
+
+
+
+
+
When an execution context is established for evaluating an ECMAScript function a new function Environment Record is created and bindings for each formal parameter are instantiated in that Environment Record. Each declaration in the function body is also instantiated. If the function's formal parameters do not include any default value initializers then the body declarations are instantiated in the same Environment Record as the parameters. If default value parameter initializers exist, a second Environment Record is created for the body declarations. Formal parameters and functions are initialized as part of FunctionDeclarationInstantiation. All other bindings are initialized during evaluation of the function body.
+
+
FunctionDeclarationInstantiation is performed as follows using arguments _func_ and _argumentsList_. _func_ is the function object for which the execution context is being established.
+
+ 1. Let _calleeContext_ be the running execution context.
+ 1. Let _env_ be the LexicalEnvironment of _calleeContext_.
+ 1. Let _envRec_ be _env_'s EnvironmentRecord.
+ 1. Let _code_ be the value of the [[ECMAScriptCode]] internal slot of _func_.
+ 1. Let _strict_ be the value of the [[Strict]] internal slot of _func_.
+ 1. Let _formals_ be the value of the [[FormalParameters]] internal slot of _func_.
+ 1. Let _parameterNames_ be the BoundNames of _formals_.
+ 1. If _parameterNames_ has any duplicate entries, let _hasDuplicates_ be *true*. Otherwise, let _hasDuplicates_ be *false*.
+ 1. Let _simpleParameterList_ be IsSimpleParameterList of _formals_.
+ 1. Let _hasParameterExpressions_ be ContainsExpression of _formals_.
+ 1. Let _varNames_ be the VarDeclaredNames of _code_.
+ 1. Let _varDeclarations_ be the VarScopedDeclarations of _code_.
+ 1. Let _lexicalNames_ be the LexicallyDeclaredNames of _code_.
+ 1. Let _functionNames_ be an empty List.
+ 1. Let _functionsToInitialize_ be an empty List.
+ 1. For each _d_ in _varDeclarations_, in reverse list order do
+ 1. If _d_ is neither a |VariableDeclaration| or a |ForBinding|, then
+ 1. Assert: _d_ is either a |FunctionDeclaration| or a |GeneratorDeclaration|.
+ 1. Let _fn_ be the sole element of the BoundNames of _d_.
+ 1. If _fn_ is not an element of _functionNames_, then
+ 1. Insert _fn_ as the first element of _functionNames_.
+ 1. NOTE If there are multiple |FunctionDeclaration|s or |GeneratorDeclaration|s for the same name, the last declaration is used.
+ 1. Insert _d_ as the first element of _functionsToInitialize_.
+ 1. Let _argumentsObjectNeeded_ be *true*.
+ 1. If the value of the [[ThisMode]] internal slot of _func_ is ~lexical~, then
+ 1. NOTE Arrow functions never have an arguments objects.
+ 1. Let _argumentsObjectNeeded_ be *false*.
+ 1. Else if `"arguments"` is an element of _parameterNames_, then
+ 1. Let _argumentsObjectNeeded_ be *false*.
+ 1. Else if _hasParameterExpressions_ is *false*, then
+ 1. If `"arguments"` is an element of _functionNames_ or if `"arguments"` is an element of _lexicalNames_, then
+ 1. Let _argumentsObjectNeeded_ be *false*.
+ 1. For each String _paramName_ in _parameterNames_, do
+ 1. Let _alreadyDeclared_ be _envRec_.HasBinding(_paramName_).
+ 1. NOTE Early errors ensure that duplicate parameter names can only occur in non-strict functions that do not have parameter default values or rest parameters.
+ 1. If _alreadyDeclared_ is *false*, then
+ 1. Let _status_ be _envRec_.CreateMutableBinding(_paramName_).
+ 1. If _hasDuplicates_ is *true*, then
+ 1. Let _status_ be _envRec_.InitializeBinding(_paramName_, *undefined*).
+ 1. Assert: _status_ is never an abrupt completion for either of the above operations.
+ 1. If _argumentsObjectNeeded_ is *true*, then
+ 1. If _strict_ is *true* or if _simpleParameterList_ is *false*, then
+ 1. Let _ao_ be CreateUnmappedArgumentsObject(_argumentsList_).
+ 1. Else,
+ 1. NOTE mapped argument object is only provided for non-strict functions that don't have a rest parameter, any parameter default value initializers, or any destructured parameters .
+ 1. Let _ao_ be CreateMappedArgumentsObject(_func_, _formals_, _argumentsList_, _env_).
+ 1. If _strict_ is *true*, then
+ 1. Let _status_ be _envRec_.CreateImmutableBinding(`"arguments"`).
+ 1. Else,
+ 1. Let _status_ be _envRec_.CreateMutableBinding(`"arguments"`).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Call _envRec_.InitializeBinding(`"arguments"`, _ao_).
+ 1. Append `"arguments"` to _parameterNames_.
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: CreateListIterator(_argumentsList_), [[done]]: *false*}.
+ 1. If _hasDuplicates_ is *true*, then
+ 1. Let _formalStatus_ be IteratorBindingInitialization for _formals_ with _iteratorRecord_ and *undefined* as arguments.
+ 1. Else,
+ 1. Let _formalStatus_ be IteratorBindingInitialization for _formals_ with _iteratorRecord_ and _env_ as arguments.
+ 1. ReturnIfAbrupt(_formalStatus_).
+ 1. If _hasParameterExpressions_ is *false*, then
+ 1. NOTE Only a single lexical environment is needed for the parameters and top-level vars.
+ 1. Let _instantiatedVarNames_ be a copy of the List _parameterNames_.
+ 1. For each _n_ in _varNames_, do
+ 1. If _n_ is not an element of _instantiatedVarNames_, then
+ 1. Append _n_ to _instantiatedVarNames_.
+ 1. Let _status_ be _envRec_.CreateMutableBinding(_n_).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Call _envRec_.InitializeBinding(_n_, *undefined*).
+ 1. Let _varEnv_ be _env_.
+ 1. Let _varEnvRec_ be _envRec_.
+ 1. Else,
+ 1. NOTE A separate Environment Record is needed to ensure that closures created by expressions in the formal parameter list do not have visibility of declarations in the function body.
+ 1. Let _varEnv_ be NewDeclarativeEnvironment(_env_).
+ 1. Let _varEnvRec_ be _varEnv_'s EnvironmentRecord.
+ 1. Set the VariableEnvironment of _calleeContext_ to _varEnv_.
+ 1. Let _instantiatedVarNames_ be a new empty List.
+ 1. For each _n_ in _varNames_, do
+ 1. If _n_ is not an element of _instantiatedVarNames_, then
+ 1. Append _n_ to _instantiatedVarNames_.
+ 1. Let _status_ be _varEnvRec_.CreateMutableBinding(_n_).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. If _n_ is not an element of _parameterNames_ or if _n_ is an element of _functionNames_, let _initialValue_ be *undefined*.
+ 1. Else,
+ 1. Let _initialValue_ be _envRec_.GetBindingValue(_n_, *false*).
+ 1. Assert: _initialValue_ is never an abrupt completion.
+ 1. Call _varEnvRec_.InitializeBinding(_n_, _initialValue_).
+ 1. NOTE vars whose names are the same as a formal parameter, initially have the same value as the corresponding initialized parameter.
+ 1. NOTE: Annex adds additional steps at this point.
+ 1. If _strict_ is *false*, then
+ 1. Let _lexEnv_ be NewDeclarativeEnvironment(_varEnv_).
+ 1. NOTE: Non-strict functions use a separate lexical Environment Record for top-level lexical declarations so that a direct `eval` (see ) can determine whether any var scoped declarations introduced by the eval code conflict with pre-existing top-level lexically scoped declarations. This is not needed for strict functions because a strict direct `eval` always places all declarations into a new Environment Record.
+ 1. Else, let _lexEnv_ be _varEnv_.
+ 1. Let _lexEnvRec_ be _lexEnv_'s EnvironmentRecord.
+ 1. Set the LexicalEnvironment of _calleeContext_ to _lexEnv_.
+ 1. Let _lexDeclarations_ be the LexicallyScopedDeclarations of _code_.
+ 1. For each element _d_ in _lexDeclarations_ do
+ 1. NOTE A lexically declared name cannot be the same as a function/generator declaration, formal parameter, or a var name. Lexically declared names are only instantiated here but not initialized.
+ 1. For each element _dn_ of the BoundNames of _d_ do
+ 1. If IsConstantDeclaration of _d_ is *true*, then
+ 1. Let _status_ be _lexEnvRec_.CreateImmutableBinding(_dn_, *true*).
+ 1. Else,
+ 1. Let _status_ be _lexEnvRec_.CreateMutableBinding(_dn_, *false*).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. For each parsed grammar phrase _f_ in _functionsToInitialize_, do
+ 1. Let _fn_ be the sole element of the BoundNames of _f_.
+ 1. Let _fo_ be the result of performing InstantiateFunctionObject for _f_ with argument _lexEnv_.
+ 1. Let _status_ be _varEnvRec_.SetMutableBinding(_fn_, _fo_, *false*).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Return NormalCompletion(~empty~).
+
+
+
provides an extension to the above algorithm that is necessary for backwards compatibility with web browser implementations of ECMAScript that predate ECMAScript 2015.
+
+
+
Parameter |Initializer|s may contain direct eval expressions (). Any top level declarations of such evals are only visible to the eval code (). The creation of the environment for such declarations is described in .
+
+
+
+
+
+
+
Built-in Function Objects
+
The built-in function objects defined in this specification may be implemented as either ECMAScript function objects () whose behaviour is provided using ECMAScript code or as implementation provided exotic function objects whose behaviour is provided in some other manner. In either case, the effect of calling such functions must conform to their specifications. An implementation may also provide additional built-in function objects that are not defined in this specification.
+
If a built-in function object is implemented as an exotic object it must have the ordinary object behaviour specified in . All such exotic function objects also have [[Prototype]], [[Extensible]], [[Realm]], and [[ScriptOrModule]] internal slots.
+
Unless otherwise specified every built-in function object has the %FunctionPrototype% object () as the initial value of its [[Prototype]] internal slot.
+
The behaviour specified for each built-in function via algorithm steps or other means is the specification of the function body behaviour for both [[Call]] and [[Construct]] invocations of the function. However, [[Construct]] invocation is not supported by all built-in functions. For each built-in function, when invoked with [[Call]], the [[Call]] _thisArgument_ provides the *this* value, the [[Call]] _argumentsList_ provides the named parameters, and the NewTarget value is *undefined*. When invoked with [[Construct]], the *this* value is uninitialized, the [[Construct]] _argumentsList_ provides the named parameters, and the [[Construct]] _newTarget_ parameter provides the NewTarget value. If the built-in function is implemented as an ECMAScript function object then this specified behaviour must be implemented by the ECMAScript code that is the body of the function. Built-in functions that are ECMAScript function objects must be strict mode functions. If a built-in constructor has any [[Call]] behaviour other than throwing a *TypeError* exception, an ECMAScript implementation of the function must be done in a manner that does not cause the function's [[FunctionKind]] internal slot to have the value `"classConstructor"`.
+
Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function. When a built-in constructor is called as part of a `new` expression the _argumentsList_ parameter of the invoked [[Construct]] internal method provides the values for the built-in constructor's named parameters.
+
Built-in functions that are not constructors do not have a `prototype` property unless otherwise specified in the description of a particular function.
+
If a built-in function object is not implemented as an ECMAScript function it must provide [[Call]] and [[Construct]] internal methods that conform to the following definitions:
+
+
+
+
[[Call]] ( _thisArgument_, _argumentsList_)
+
The [[Call]] internal method for a built-in function object _F_ is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values. The following steps are taken:
+
+ 1. Let _callerContext_ be the running execution context.
+ 1. If _callerContext_ is not already suspended, Suspend _callerContext_.
+ 1. Let _calleeContext_ be a new ECMAScript code execution context.
+ 1. Set the Function of _calleeContext_ to _F_.
+ 1. Let _calleeRealm_ be the value of _F_'s [[Realm]] internal slot.
+ 1. Set the Realm of _calleeContext_ to _calleeRealm_.
+ 1. Set the ScriptOrModule of _calleeContext_ to the value of _F_'s [[ScriptOrModule]] internal slot.
+ 1. Perform any necessary implementation defined initialization of _calleeContext_.
+ 1. Push _calleeContext_ onto the execution context stack; _calleeContext_ is now the running execution context.
+ 1. Let _result_ be the Completion Record that is the result of evaluating _F_ in an implementation defined manner that conforms to the specification of _F_. _thisArgument_ is the *this* value, _argumentsList_ provides the named parameters, and the NewTarget value is *undefined*.
+ 1. Remove _calleeContext_ from the execution context stack and restore _callerContext_ as the running execution context.
+ 1. Return _result_.
+
+
+
When _calleeContext_ is removed from the execution context stack it must not be destroyed if it has been suspended and retained by an accessible generator object for later resumption.
+
+
+
+
+
+
[[Construct]] (_argumentsList_, _newTarget_)
+
The [[Construct]] internal method for built-in function object _F_ is called with parameters _argumentsList_ and _newTarget_. The steps performed are the same as [[Call]] (see ) except that step 10 is replaced by:
+
+ 10. Let _result_ be the Completion Record that is the result of evaluating _F_ in an implementation defined manner that conforms to the specification of _F_. The *this* value is uninitialized, _argumentsList_ provides the named parameters, and _newTarget_ provides the NewTarget value.
+
+
+
+
+
+
The abstract operation CreateBuiltinFunction takes arguments _realm_, _prototype_, and _steps_. The optional argument _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. If the list is not provided, an empty List is used. CreateBuiltinFunction returns a built-in function object created by the following steps:
+
+ 1. Assert: _realm_ is a Realm Record.
+ 1. Assert: _steps_ is either a set of algorithm steps or other definition of a functions behaviour provided in this specification.
+ 1. Let _func_ be a new built-in function object that when called performs the action described by _steps_. The new function object has internal slots whose names are the elements of _internalSlotsList_. The initial value of each of those internal slots is *undefined*.
+ 1. Set the [[Realm]] internal slot of _func_ to _realm_.
+ 1. Set the [[Prototype]] internal slot of _func_ to _prototype_.
+ 1. Set the [[Extensible]] internal slot of _func_ to *true*.
+ 1. Return _func_.
+
+
Each built-in function defined in this specification is created as if by calling the CreateBuiltinFunction abstract operation, unless otherwise specified.
+
+
+
+
+
+
Built-in Exotic Object Internal Methods and Slots
+
This specification defines several kinds of built-in exotic objects. These objects generally behave similar to ordinary objects except for a few specific situations. The following exotic objects use the ordinary object internal methods except where it is explicitly specified otherwise below:
+
+
+
+
Bound Function Exotic Objects
+
A bound function is an exotic object that wraps another function object. A bound function is callable (it has a [[Call]] internal method and may have a [[Construct]] internal method). Calling a bound function generally results in a call of its wrapped function.
+
Bound function objects do not have the internal slots of ECMAScript function objects defined in . Instead they have the internal slots defined in .
+
+
+
+
+
+ Internal Slot
+
+
+ Type
+
+
+ Description
+
+
+
+
+ [[BoundTargetFunction]]
+
+
+ Callable Object
+
+
+ The wrapped function object.
+
+
+
+
+ [[BoundThis]]
+
+
+ Any
+
+
+ The value that is always passed as the *this* value when calling the wrapped function.
+
+
+
+
+ [[BoundArguments]]
+
+
+ List of Any
+
+
+ A list of values whose elements are used as the first arguments to any call to the wrapped function.
+
+
+
+
+
+
Unlike ECMAScript function objects, bound function objects do not use an alternative definition of the [[GetOwnProperty]] internal methods. Bound function objects provide all of the essential internal methods as specified in . However, they use the following definitions for the essential internal methods of function objects.
+
+
+
+
[[Call]] ( _thisArgument_, _argumentsList_)
+
When the [[Call]] internal method of an exotic bound function object, _F_, which was created using the bind function is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values, the following steps are taken:
+
+ 1. Let _target_ be the value of _F_'s [[BoundTargetFunction]] internal slot.
+ 1. Let _boundThis_ be the value of _F_'s [[BoundThis]] internal slot.
+ 1. Let _boundArgs_ be the value of _F_'s [[BoundArguments]] internal slot.
+ 1. Let _args_ be a new list containing the same values as the list _boundArgs_ in the same order followed by the same values as the list _argumentsList_ in the same order.
+ 1. Return Call(_target_, _boundThis_, _args_).
+
+
+
+
+
+
[[Construct]] (_argumentsList_, _newTarget_)
+
When the [[Construct]] internal method of an exotic bound function object, _F_ that was created using the bind function is called with a list of arguments _argumentsList_ and _newTarget_, the following steps are taken:
+
+ 1. Let _target_ be the value of _F_'s [[BoundTargetFunction]] internal slot.
+ 1. Assert: _target_ has a [[Construct]] internal method.
+ 1. Let _boundArgs_ be the value of _F_'s [[BoundArguments]] internal slot.
+ 1. Let _args_ be a new list containing the same values as the list _boundArgs_ in the same order followed by the same values as the list _argumentsList_ in the same order.
+ 1. If SameValue(_F_, _newTarget_) is *true*, let _newTarget_ be _target_.
+ 1. Return Construct(_target_, _args_, _newTarget_).
+
+
+
+
+
+
The abstract operation BoundFunctionCreate with arguments _targetFunction_, _boundThis_ and _boundArgs_ is used to specify the creation of new Bound Function exotic objects. It performs the following steps:
+
+ 1. Assert: Type(_targetFunction_) is Object.
+ 1. Let _proto_ be ? _targetFunction_.[[GetPrototypeOf]]().
+ 1. Let _obj_ be a newly created object.
+ 1. Set _obj_'s essential internal methods to the default ordinary object definitions specified in .
+ 1. Set the [[Call]] internal method of _obj_ as described in .
+ 1. If _targetFunction_ has a [[Construct]] internal method, then
+ 1. Set the [[Construct]] internal method of _obj_ as described in .
+ 1. Set the [[Prototype]] internal slot of _obj_ to _proto_.
+ 1. Set the [[Extensible]] internal slot of _obj_ to *true*.
+ 1. Set the [[BoundTargetFunction]] internal slot of _obj_ to _targetFunction_.
+ 1. Set the [[BoundThis]] internal slot of _obj_ to the value of _boundThis_.
+ 1. Set the [[BoundArguments]] internal slot of _obj_ to _boundArgs_.
+ 1. Return _obj_.
+
+
+
+
+
+
+
Array Exotic Objects
+
An Array object is an exotic object that gives special treatment to array index property keys (see ). A property whose property name is an array index is also called an element. Every Array object has a `length` property whose value is always a nonnegative integer less than 232. The value of the `length` property is numerically greater than the name of every own property whose name is an array index; whenever an own property of an Array object is created or changed, other properties are adjusted as necessary to maintain this invariant. Specifically, whenever an own property is added whose name is an array index, the value of the `length` property is changed, if necessary, to be one more than the numeric value of that array index; and whenever the value of the `length` property is changed, every own property whose name is an array index whose value is not smaller than the new length is deleted. This constraint applies only to own properties of an Array object and is unaffected by `length` or array index properties that may be inherited from its prototypes.
+
+
A String property name _P_ is an array index if and only if ToString(ToUint32(_P_)) is equal to _P_ and ToUint32(_P_) is not equal to 232-1.
+
+
Array exotic objects always have a non-configurable property named `"length"`.
+
Array exotic objects provide an alternative definition for the [[DefineOwnProperty]] internal method. Except for that internal method, Array exotic objects provide all of the other essential internal methods as specified in .
+
+
+
+
[[DefineOwnProperty]] ( _P_, _Desc_)
+
When the [[DefineOwnProperty]] internal method of an Array exotic object _A_ is called with property key _P_, and Property Descriptor _Desc_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. If _P_ is `"length"`, then
+ 1. Return ArraySetLength(_A_, _Desc_).
+ 1. Else if _P_ is an array index, then
+ 1. Let _oldLenDesc_ be OrdinaryGetOwnProperty(_A_, `"length"`).
+ 1. Assert: _oldLenDesc_ will never be *undefined* or an accessor descriptor because Array objects are created with a length data property that cannot be deleted or reconfigured.
+ 1. Let _oldLen_ be _oldLenDesc_.[[Value]].
+ 1. Let _index_ be ToUint32(_P_).
+ 1. Assert: _index_ will never be an abrupt completion.
+ 1. If _index_ ≥ _oldLen_ and _oldLenDesc_.[[Writable]] is *false*, return *false*.
+ 1. Let _succeeded_ be OrdinaryDefineOwnProperty(_A_, _P_, _Desc_).
+ 1. Assert: _succeeded_ is not an abrupt completion.
+ 1. If _succeeded_ is *false*, return *false*.
+ 1. If _index_ ≥ _oldLen_, then
+ 1. Set _oldLenDesc_.[[Value]] to _index_ + 1.
+ 1. Let _succeeded_ be OrdinaryDefineOwnProperty(_A_, `"length"`, _oldLenDesc_).
+ 1. Assert: _succeeded_ is *true*.
+ 1. Return *true*.
+ 1. Return OrdinaryDefineOwnProperty(_A_, _P_, _Desc_).
+
+
+
+
+
+
ArrayCreate(_length_, _proto_)
+
The abstract operation ArrayCreate with argument _length_ (a positive integer) and optional argument _proto_ is used to specify the creation of new Array exotic objects. It performs the following steps:
+
+ 1. Assert: _length_ is an integer Number ≥ 0.
+ 1. If _length_ is -0, let _length_ be +0.
+ 1. If _length_>232-1, throw a *RangeError* exception.
+ 1. If the _proto_ argument was not passed, let _proto_ be the intrinsic object %ArrayPrototype%.
+ 1. Let _A_ be a newly created Array exotic object.
+ 1. Set _A_'s essential internal methods except for [[DefineOwnProperty]] to the default ordinary object definitions specified in .
+ 1. Set the [[DefineOwnProperty]] internal method of _A_ as specified in .
+ 1. Set the [[Prototype]] internal slot of _A_ to _proto_.
+ 1. Set the [[Extensible]] internal slot of _A_ to *true*.
+ 1. Perform OrdinaryDefineOwnProperty(_A_, `"length"`, PropertyDescriptor{[[Value]]: _length_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Assert: the preceding step never produces an abrupt completion.
+ 1. Return _A_.
+
+
+
+
+
+
ArraySpeciesCreate(_originalArray_, _length_)
+
The abstract operation ArraySpeciesCreate with arguments _originalArray_ and _length_ is used to specify the creation of a new Array object using a constructor function that is derived from _originalArray_. It performs the following steps:
+
+ 1. Assert: _length_ is an integer Number ≥ 0.
+ 1. If _length_ is -0, let _length_ be +0.
+ 1. Let _C_ be *undefined*.
+ 1. Let _isArray_ be ? IsArray(_originalArray_).
+ 1. If _isArray_ is *true*, then
+ 1. Let _C_ be ? Get(_originalArray_, `"constructor"`).
+ 1. If IsConstructor(_C_) is *true*, then
+ 1. Let _thisRealm_ be the running execution context's Realm.
+ 1. Let _realmC_ be ? GetFunctionRealm(_C_).
+ 1. If _thisRealm_ and _realmC_ are not the same Realm Record, then
+ 1. If SameValue(_C_, _realmC_.[[intrinsics]].[[%Array%]]) is *true*, let _C_ be *undefined*.
+ 1. If Type(_C_) is Object, then
+ 1. Let _C_ be ? Get(_C_, @@species).
+ 1. If _C_ is *null*, let _C_ be *undefined*.
+ 1. If _C_ is *undefined*, return ArrayCreate(_length_).
+ 1. If IsConstructor(_C_) is *false*, throw a *TypeError* exception.
+ 1. Return Construct(_C_, « _length_ »).
+
+
+
If _originalArray_ was created using the standard built-in Array constructor for a Realm that is not the Realm of the running execution context, then a new Array is created using the Realm of the running execution context. This maintains compatibility with Web browsers that have historically had that behaviour for the Array.prototype methods that now are defined using ArraySpeciesCreate.
+
+
+
+
+
+
ArraySetLength(_A_, _Desc_)
+
When the abstract operation ArraySetLength is called with an Array exotic object _A_, and Property Descriptor _Desc_ the following steps are taken:
+
+ 1. If the [[Value]] field of _Desc_ is absent, then
+ 1. Return OrdinaryDefineOwnProperty(_A_, `"length"`, _Desc_).
+ 1. Let _newLenDesc_ be a copy of _Desc_.
+ 1. Let _newLen_ be ? ToUint32(_Desc_.[[Value]]).
+ 1. Let _numberLen_ be ? ToNumber(_Desc_.[[Value]]).
+ 1. If _newLen_ ≠ _numberLen_, throw a *RangeError* exception.
+ 1. Set _newLenDesc_.[[Value]] to _newLen_.
+ 1. Let _oldLenDesc_ be OrdinaryGetOwnProperty(_A_, `"length"`).
+ 1. Assert: _oldLenDesc_ will never be *undefined* or an accessor descriptor because Array objects are created with a length data property that cannot be deleted or reconfigured.
+ 1. Let _oldLen_ be _oldLenDesc_.[[Value]].
+ 1. If _newLen_ ≥_oldLen_, then
+ 1. Return OrdinaryDefineOwnProperty(_A_, `"length"`, _newLenDesc_).
+ 1. If _oldLenDesc_.[[Writable]] is *false*, return *false*.
+ 1. If _newLenDesc_.[[Writable]] is absent or has the value *true*, let _newWritable_ be *true*.
+ 1. Else,
+ 1. Need to defer setting the [[Writable]] attribute to *false* in case any elements cannot be deleted.
+ 1. Let _newWritable_ be *false*.
+ 1. Set _newLenDesc_.[[Writable]] to *true*.
+ 1. Let _succeeded_ be OrdinaryDefineOwnProperty(_A_, `"length"`, _newLenDesc_).
+ 1. Assert: _succeeded_ is not an abrupt completion.
+ 1. If _succeeded_ is *false*, return *false*.
+ 1. While _newLen_ < _oldLen_ repeat,
+ 1. Set _oldLen_ to _oldLen_ - 1.
+ 1. Let _deleteSucceeded_ be _A_.[[Delete]](ToString(_oldLen_)).
+ 1. Assert: _deleteSucceeded_ is not an abrupt completion.
+ 1. If _deleteSucceeded_ is *false*, then
+ 1. Set _newLenDesc_.[[Value]] to _oldLen_ + 1.
+ 1. If _newWritable_ is *false*, set _newLenDesc_.[[Writable]] to *false*.
+ 1. Let _succeeded_ be OrdinaryDefineOwnProperty(_A_, `"length"`, _newLenDesc_).
+ 1. Assert: _succeeded_ is not an abrupt completion.
+ 1. Return *false*.
+ 1. If _newWritable_ is *false*, then
+ 1. Return OrdinaryDefineOwnProperty(_A_, `"length"`, PropertyDescriptor{[[Writable]]: *false*}). This call will always return *true*.
+ 1. Return *true*.
+
+
+
In steps 3 and 5, if _Desc_.[[Value]] is an object then its `valueOf` method is called twice. This is legacy behaviour that was specified with this effect starting with the 2nd Edition of this specification.
+
+
+
+
+
+
+
String Exotic Objects
+
A String object is an exotic object that encapsulates a String value and exposes virtual integer indexed data properties corresponding to the individual code unit elements of the String value. Exotic String objects always have a data property named `"length"` whose value is the number of code unit elements in the encapsulated String value. Both the code unit data properties and the `"length"` property are non-writable and non-configurable.
+
Exotic String objects have the same internal slots as ordinary objects. They also have a [[StringData]] internal slot.
+
Exotic String objects provide alternative definitions for the following internal methods. All of the other exotic String object essential internal methods that are not defined below are as specified in .
+
+
+
+
[[GetOwnProperty]] ( _P_ )
+
When the [[GetOwnProperty]] internal method of an exotic String object _S_ is called with property key _P_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _desc_ be OrdinaryGetOwnProperty(_S_, _P_).
+ 1. If _desc_ is not *undefined*, return _desc_.
+ 1. Return StringGetIndexProperty(_S_, _P_).
+
+
+
+
+
StringGetIndexProperty (_S_, _P_)
+
When the abstract operation StringGetIndexProperty is called with an exotic String object _S_ and with property key _P_, the following steps are taken:
+
+ 1. If Type(_P_) is not String, return *undefined*.
+ 1. Let _index_ be CanonicalNumericIndexString(_P_).
+ 1. Assert: _index_ is not an abrupt completion.
+ 1. If _index_ is *undefined*, return *undefined*.
+ 1. If IsInteger(_index_) is *false*, return *undefined*.
+ 1. If _index_ = -0, return *undefined*.
+ 1. Let _str_ be the String value of the [[StringData]] internal slot of _S_.
+ 1. Let _len_ be the number of elements in _str_.
+ 1. If _index_ < 0 or _len_ ≤ _index_, return *undefined*.
+ 1. Let _resultStr_ be a String value of length 1, containing one code unit from _str_, specifically the code unit at index _index_.
+ 1. Return a PropertyDescriptor{ [[Value]]: _resultStr_, [[Enumerable]]: *true*, [[Writable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
+
[[HasProperty]](_P_)
+
When the [[HasProperty]] internal method of an exotic String object _S_ is called with property key _P_, the following steps are taken:
+
+ 1. Let _elementDesc_ be StringGetIndexProperty(_S_, _P_).
+ 1. If _elementDesc_ is not *undefined*, return *true*.
+ 1. Return OrdinaryHasProperty(_S_, _P_).
+
+
+
+
+
+
[[OwnPropertyKeys]] ( )
+
When the [[OwnPropertyKeys]] internal method of a String exotic object _O_ is called the following steps are taken:
+
+ 1. Let _keys_ be a new empty List.
+ 1. Let _str_ be the String value of the [[StringData]] internal slot of _O_.
+ 1. Let _len_ be the number of elements in _str_.
+ 1. For each integer _i_ starting with 0 such that _i_ < _len_, in ascending order,
+ 1. Add ToString(_i_) as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ such that _P_ is an integer index and ToInteger(_P_) ≥ _len_, in ascending numeric index order,
+ 1. Add _P_ as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ such that Type(_P_) is String and _P_ is not an integer index, in ascending chronological order of property creation,
+ 1. Add _P_ as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ such that Type(_P_) is Symbol, in ascending chronological order of property creation,
+ 1. Add _P_ as the last element of _keys_.
+ 1. Return _keys_.
+
+
+
+
+
+
StringCreate( _value_, _prototype_)
+
The abstract operation StringCreate with arguments _value_ and _prototype_ is used to specify the creation of new exotic String objects. It performs the following steps:
+
+ 1. ReturnIfAbrupt(_prototype_).
+ 1. Assert: Type(_value_) is String.
+ 1. Let _S_ be a newly created String exotic object.
+ 1. Set the [[StringData]] internal slot of _S_ to _value_.
+ 1. Set _S_'s essential internal methods to the default ordinary object definitions specified in .
+ 1. Set the [[GetOwnProperty]] internal method of _S_ as specified in .
+ 1. Set the [[HasProperty]] internal method of _S_ as specified in .
+ 1. Set the [[OwnPropertyKeys]] internal method of _S_ as specified in .
+ 1. Set the [[Prototype]] internal slot of _S_ to _prototype_.
+ 1. Set the [[Extensible]] internal slot of _S_ to *true*.
+ 1. Let _length_ be the number of code unit elements in _value_.
+ 1. Let _status_ be DefinePropertyOrThrow(_S_, `"length"`, PropertyDescriptor{[[Value]]: _length_, [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return _S_.
+
+
+
+
+
+
+
Arguments Exotic Objects
+
Most ECMAScript functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an ordinary object or an arguments exotic object. An arguments exotic object is an exotic object whose array index properties map to the formal parameters bindings of an invocation of its associated ECMAScript function.
+
Arguments exotic objects have the same internal slots as ordinary objects. They also have a [[ParameterMap]] internal slot. Ordinary arguments objects also have a [[ParameterMap]] internal slot whose value is always undefined. For ordinary argument objects the [[ParameterMap]] internal slot is only used by `Object.prototype.toString` () to identify them as such.
+
Arguments exotic objects provide alternative definitions for the following internal methods. All of the other exotic arguments object essential internal methods that are not defined below are as specified in
+
+
For non-strict functions the integer indexed data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object's properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
+
+
+
The ParameterMap object and its property values are used as a device for specifying the arguments object correspondence to argument bindings. The ParameterMap object and the objects that are the values of its properties are not directly observable from ECMAScript code. An ECMAScript implementation does not need to actually create or use such objects to implement the specified semantics.
+
+
+
Arguments objects for strict mode functions define non-configurable accessor properties named `"caller"` and `"callee"` which throw a *TypeError* exception on access. The `"callee"` property has a more specific meaning for non-strict functions and a `"caller"` property has historically been provided as an implementation-defined extension by some ECMAScript implementations. The strict mode definition of these properties exists to ensure that neither of them is defined in any other manner by conforming ECMAScript implementations.
+
+
+
+
+
[[GetOwnProperty]] (_P_)
+
The [[GetOwnProperty]] internal method of an arguments exotic object when called with a property key _P_ performs the following steps:
+
+ 1. Let _args_ be the arguments object.
+ 1. Let _desc_ be OrdinaryGetOwnProperty(_args_, _P_).
+ 1. If _desc_ is *undefined*, return _desc_.
+ 1. Let _map_ be the value of the [[ParameterMap]] internal slot of the arguments object.
+ 1. Let _isMapped_ be HasOwnProperty(_map_, _P_).
+ 1. Assert: _isMapped_ is never an abrupt completion.
+ 1. If the value of _isMapped_ is *true*, then
+ 1. Set _desc_.[[Value]] to Get(_map_, _P_).
+ 1. If IsDataDescriptor(_desc_) is *true* and _P_ is `"caller"` and _desc_.[[Value]] is a strict mode Function object, throw a *TypeError* exception.
+ 1. Return _desc_.
+
+
If an implementation does not provide a built-in `caller` property for argument exotic objects then step 8 of this algorithm must be skipped.
+
+
+
+
+
[[DefineOwnProperty]] (_P_, _Desc_)
+
The [[DefineOwnProperty]] internal method of an arguments exotic object when called with a property key _P_ and Property Descriptor _Desc_ performs the following steps:
+
+ 1. Let _args_ be the arguments object.
+ 1. Let _map_ be the value of the [[ParameterMap]] internal slot of the arguments object.
+ 1. Let _isMapped_ be HasOwnProperty(_map_, _P_).
+ 1. Let _newArgDesc_ be _Desc_.
+ 1. If _isMapped_ is *true* and IsDataDescriptor(_Desc_) is *true*, then
+ 1. If _Desc_.[[Value]] is not present and _Desc_.[[Writable]] is present and its value is *false*, then
+ 1. Let _newArgDesc_ be a copy of _Desc_.
+ 1. Set _newArgDesc_.[[Value]] to Get(_map_, _P_).
+ 1. Let _allowed_ be ? OrdinaryDefineOwnProperty(_args_, _P_, _newArgDesc_).
+ 1. If _allowed_ is *false*, return *false*.
+ 1. If the value of _isMapped_ is *true*, then
+ 1. If IsAccessorDescriptor(_Desc_) is *true*, then
+ 1. Call _map_.[[Delete]](_P_).
+ 1. Else,
+ 1. If _Desc_.[[Value]] is present, then
+ 1. Let _setStatus_ be Set(_map_, _P_, _Desc_.[[Value]], *false*).
+ 1. Assert: _setStatus_ is *true* because formal parameters mapped by argument objects are always writable.
+ 1. If _Desc_.[[Writable]] is present and its value is *false*, then
+ 1. Call _map_.[[Delete]](_P_).
+ 1. Return *true*.
+
+
+
+
+
+
[[Get]] (_P_, _Receiver_)
+
The [[Get]] internal method of an arguments exotic object when called with a property key _P_ and ECMAScript language value _Receiver_ performs the following steps:
+
+ 1. Let _args_ be the arguments object.
+ 1. Let _map_ be the value of the [[ParameterMap]] internal slot of the arguments object.
+ 1. Let _isMapped_ be HasOwnProperty(_map_, _P_).
+ 1. Assert: _isMapped_ is not an abrupt completion.
+ 1. If the value of _isMapped_ is *false*, then
+ 1. Return the result of calling the default ordinary object [[Get]] internal method () on _args_ passing _P_ and _Receiver_ as the arguments.
+ 1. Else _map_ contains a formal parameter mapping for _P_,
+ 1. Return Get(_map_, _P_).
+
+
+
+
+
+
[[Set]] ( _P_, _V_, _Receiver_)
+
The [[Set]] internal method of an arguments exotic object when called with property key _P_, value _V_, and ECMAScript language value _Receiver_ performs the following steps:
+
+ 1. Let _args_ be the arguments object.
+ 1. If SameValue(_args_, _Receiver_) is *false*, then
+ 1. Let _isMapped_ be *false*.
+ 1. Else,
+ 1. Let _map_ be the value of the [[ParameterMap]] internal slot of the arguments object.
+ 1. Let _isMapped_ be HasOwnProperty(_map_, _P_).
+ 1. Assert: _isMapped_ is not an abrupt completion.
+ 1. If _isMapped_ is *true*, then
+ 1. Let _setStatus_ be Set(_map_, _P_, _V_, *false*).
+ 1. Assert: _setStatus_ is *true* because formal parameters mapped by argument objects are always writable.
+ 1. Return the result of calling the default ordinary object [[Set]] internal method () on _args_ passing _P_, _V_ and _Receiver_ as the arguments.
+
+
+
+
+
+
[[Delete]] (_P_)
+
The [[Delete]] internal method of an arguments exotic object when called with a property key _P_ performs the following steps:
+
+ 1. Let _map_ be the value of the [[ParameterMap]] internal slot of the arguments object.
+ 1. Let _isMapped_ be HasOwnProperty(_map_, _P_).
+ 1. Assert: _isMapped_ is not an abrupt completion.
+ 1. Let _result_ be the result of calling the default [[Delete]] internal method for ordinary objects () on the arguments object passing _P_ as the argument.
+ 1. ReturnIfAbrupt(_result_).
+ 1. If _result_ is *true* and the value of _isMapped_ is *true*, then
+ 1. Call _map_.[[Delete]](_P_).
+ 1. Return _result_.
+
+
+
+
+
+
CreateUnmappedArgumentsObject(_argumentsList_)
+
The abstract operation CreateUnmappedArgumentsObject called with an argument _argumentsList_ performs the following steps:
+
+ 1. Let _len_ be the number of elements in _argumentsList_.
+ 1. Let _obj_ be ObjectCreate(%ObjectPrototype%, « [[ParameterMap]] »).
+ 1. Set _obj_'s [[ParameterMap]] internal slot to *undefined*.
+ 1. Perform DefinePropertyOrThrow(_obj_, `"length"`, PropertyDescriptor{[[Value]]: _len_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Let _index_ be 0.
+ 1. Repeat while _index_ < _len_,
+ 1. Let _val_ be _argumentsList_[_index_].
+ 1. Perform CreateDataProperty(_obj_, ToString(_index_), _val_).
+ 1. Let _index_ be _index_ + 1.
+ 1. Perform DefinePropertyOrThrow(_obj_, @@iterator, PropertyDescriptor {[[Value]]:%ArrayProto_values%, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Perform DefinePropertyOrThrow(_obj_, `"callee"`, PropertyDescriptor {[[Get]]: %ThrowTypeError%, [[Set]]: %ThrowTypeError%, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Perform DefinePropertyOrThrow(_obj_, `"caller"`, PropertyDescriptor {[[Get]]: %ThrowTypeError%, [[Set]]: %ThrowTypeError%, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Assert: the above property definitions will not produce an abrupt completion.
+ 1. Return _obj_.
+
+
+
+
+
+
The abstract operation CreateMappedArgumentsObject is called with object _func_, parsed grammar phrase _formals_, List _argumentsList_, and Environment Record _env_. The following steps are performed:
+
+ 1. Assert: _formals_ does not contain a rest parameter, any binding patterns, or any initializers. It may contain duplicate identifiers.
+ 1. Let _len_ be the number of elements in _argumentsList_.
+ 1. Let _obj_ be a newly created arguments exotic object with a [[ParameterMap]] internal slot.
+ 1. Set the [[GetOwnProperty]] internal method of _obj_ as specified in .
+ 1. Set the [[DefineOwnProperty]] internal method of _obj_ as specified in .
+ 1. Set the [[Get]] internal method of _obj_ as specified in .
+ 1. Set the [[Set]] internal method of _obj_ as specified in .
+ 1. Set the [[Delete]] internal method of _obj_ as specified in .
+ 1. Set the remainder of _obj_'s essential internal methods to the default ordinary object definitions specified in .
+ 1. Set the [[Prototype]] internal slot of _obj_ to %ObjectPrototype%.
+ 1. Set the [[Extensible]] internal slot of _obj_ to *true*.
+ 1. Let _map_ be ObjectCreate(*null*).
+ 1. Set the [[ParameterMap]] internal slot of _obj_ to _map_.
+ 1. Let _parameterNames_ be the BoundNames of _formals_.
+ 1. Let _numberOfParameters_ be the number of elements in _parameterNames_.
+ 1. Let _index_ be 0.
+ 1. Repeat while _index_ < _len_ ,
+ 1. Let _val_ be _argumentsList_[_index_].
+ 1. Perform CreateDataProperty(_obj_, ToString(_index_), _val_).
+ 1. Let _index_ be _index_ + 1.
+ 1. Perform DefinePropertyOrThrow(_obj_, `"length"`, PropertyDescriptor{[[Value]]: _len_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Let _mappedNames_ be an empty List.
+ 1. Let _index_ be _numberOfParameters_ - 1.
+ 1. Repeat while _index_ ≥ 0 ,
+ 1. Let _name_ be _parameterNames_[_index_].
+ 1. If _name_ is not an element of _mappedNames_, then
+ 1. Add _name_ as an element of the list _mappedNames_.
+ 1. If _index_ < _len_, then
+ 1. Let _g_ be MakeArgGetter(_name_, _env_).
+ 1. Let _p_ be MakeArgSetter(_name_, _env_).
+ 1. Perform _map_.[[DefineOwnProperty]](ToString(_index_), PropertyDescriptor{[[Set]]: _p_, [[Get]]: _g_, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Let _index_ be _index_ - 1
+ 1. Perform DefinePropertyOrThrow(_obj_, @@iterator, PropertyDescriptor {[[Value]]:%ArrayProto_values%, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Perform DefinePropertyOrThrow(_obj_, `"callee"`, PropertyDescriptor {[[Value]]: _func_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Assert: the above property definitions will not produce an abrupt completion.
+ 1. Return _obj_.
+
+
+
+
+
MakeArgGetter ( _name_, _env_)
+
The abstract operation MakeArgGetter called with String _name_ and Environment Record _env_ creates a built-in function object that when executed returns the value bound for _name_ in _env_. It performs the following steps:
+
+ 1. Let _realm_ be the current Realm.
+ 1. Let _steps_ be the steps of an ArgGetter function as specified below.
+ 1. Let _getter_ be CreateBuiltinFunction(_realm_, _steps_, %FunctionPrototype%, « [[name]], [[env]] » ).
+ 1. Set _getter_'s [[name]] internal slot to _name_.
+ 1. Set _getter_'s [[env]] internal slot to _env_.
+ 1. Return _getter_.
+
+
An ArgGetter function is an anonymous built-in function with [[name]] and [[env]] internal slots. When an ArgGetter function _f_ that expects no arguments is called it performs the following steps:
+
+ 1. Let _name_ be the value of _f_'s [[name]] internal slot.
+ 1. Let _env_ be the value of _f_'s [[env]] internal slot.
+ 1. Return _env_.GetBindingValue(_name_, *false*).
+
+
+
ArgGetter functions are never directly accessible to ECMAScript code.
+
+
+
+
+
+
MakeArgSetter ( _name_, _env_)
+
The abstract operation MakeArgSetter called with String _name_ and Environment Record _env_ creates a built-in function object that when executed sets the value bound for _name_ in _env_. It performs the following steps:
+
+ 1. Let _realm_ be the current Realm.
+ 1. Let _steps_ be the steps of an ArgSetter function as specified below.
+ 1. Let _setter_ be CreateBuiltinFunction(_realm_, _steps_, %FunctionPrototype%, « [[name]], [[env]] » ).
+ 1. Set _setter_'s [[name]] internal slot to _name_.
+ 1. Set _setter_'s [[env]] internal slot to _env_.
+ 1. Return _setter_.
+
+
An ArgSetter function is an anonymous built-in function with [[name]] and [[env]] internal slots. When an ArgSetter function _f_ is called with argument _value_ it performs the following steps:
+
+ 1. Let _name_ be the value of _f_'s [[name]] internal slot.
+ 1. Let _env_ be the value of _f_'s [[env]] internal slot.
+ 1. Return _env_.SetMutableBinding(_name_, _value_, *false*).
+
+
+
ArgSetter functions are never directly accessible to ECMAScript code.
+
+
+
+
+
+
+
+
Integer Indexed Exotic Objects
+
An Integer Indexed object is an exotic object that performs special handling of integer index property keys.
+
Integer Indexed exotic objects have the same internal slots as ordinary objects and additionally [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] internal slots.
+
Integer Indexed exotic objects provide alternative definitions for the following internal methods. All of the other Integer Indexed exotic object essential internal methods that are not defined below are as specified in .
+
+
+
+
[[GetOwnProperty]] ( _P_ )
+
When the [[GetOwnProperty]] internal method of an Integer Indexed exotic object _O_ is called with property key _P_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Assert: _O_ is an Object that has a [[ViewedArrayBuffer]] internal slot.
+ 1. If Type(_P_) is String, then
+ 1. Let _numericIndex_ be CanonicalNumericIndexString(_P_).
+ 1. Assert: _numericIndex_ is not an abrupt completion.
+ 1. If _numericIndex_ is not *undefined*, then
+ 1. Let _value_ be ? IntegerIndexedElementGet(_O_, _numericIndex_).
+ 1. If _value_ is *undefined*, return *undefined*.
+ 1. Return a PropertyDescriptor{ [[Value]]: _value_, [[Enumerable]]: *true*, [[Writable]]: *true*, [[Configurable]]: *false* }.
+ 1. Return OrdinaryGetOwnProperty(_O_, _P_).
+
+
+
+
+
+
[[HasProperty]](_P_)
+
When the [[HasProperty]] internal method of an Integer Indexed exotic object _O_ is called with property key _P_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Assert: _O_ is an Object that has a [[ViewedArrayBuffer]] internal slot.
+ 1. If Type(_P_) is String, then
+ 1. Let _numericIndex_ be CanonicalNumericIndexString(_P_).
+ 1. Assert: _numericIndex_ is not an abrupt completion.
+ 1. If _numericIndex_ is not *undefined*, then
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. If IsInteger(_numericIndex_) is *false*, return *false*.
+ 1. If _numericIndex_ = -0, return *false*.
+ 1. If _numericIndex_ < 0, return *false*.
+ 1. If _numericIndex_ ≥ the value of _O_'s [[ArrayLength]] internal slot, return *false*.
+ 1. Return *true*.
+ 1. Return OrdinaryHasProperty(_O_, _P_).
+
+
+
+
+
+
[[DefineOwnProperty]] ( _P_, _Desc_)
+
When the [[DefineOwnProperty]] internal method of an Integer Indexed exotic object _O_ is called with property key _P_, and Property Descriptor _Desc_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Assert: _O_ is an Object that has a [[ViewedArrayBuffer]] internal slot.
+ 1. If Type(_P_) is String, then
+ 1. Let _numericIndex_ be CanonicalNumericIndexString(_P_).
+ 1. Assert: _numericIndex_ is not an abrupt completion.
+ 1. If _numericIndex_ is not *undefined*, then
+ 1. If IsInteger(_numericIndex_) is *false*, return *false*.
+ 1. Let _intIndex_ be _numericIndex_.
+ 1. If _intIndex_ = -0, return *false*.
+ 1. If _intIndex_ < 0, return *false*.
+ 1. Let _length_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. If _intIndex_ ≥ _length_, return *false*.
+ 1. If IsAccessorDescriptor(_Desc_) is *true*, return *false*.
+ 1. If _Desc_ has a [[Configurable]] field and if _Desc_.[[Configurable]] is *true*, return *false*.
+ 1. If _Desc_ has an [[Enumerable]] field and if _Desc_.[[Enumerable]] is *false*, return *false*.
+ 1. If _Desc_ has a [[Writable]] field and if _Desc_.[[Writable]] is *false*, return *false*.
+ 1. If _Desc_ has a [[Value]] field, then
+ 1. Let _value_ be _Desc_.[[Value]].
+ 1. Return IntegerIndexedElementSet(_O_, _intIndex_, _value_).
+ 1. Return *true*.
+ 1. Return OrdinaryDefineOwnProperty(_O_, _P_, _Desc_).
+
+
+
+
+
+
[[Get]] (_P_, _Receiver_)
+
When the [[Get]] internal method of an Integer Indexed exotic object _O_ is called with property key _P_ and ECMAScript language value _Receiver_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. If Type(_P_) is String and if SameValue(_O_, _Receiver_) is *true*, then
+ 1. Let _numericIndex_ be CanonicalNumericIndexString(_P_).
+ 1. Assert: _numericIndex_ is not an abrupt completion.
+ 1. If _numericIndex_ is not *undefined*, then
+ 1. Return IntegerIndexedElementGet(_O_, _numericIndex_).
+ 1. Return the result of calling the default ordinary object [[Get]] internal method () on _O_ passing _P_ and _Receiver_ as arguments.
+
+
+
+
+
+
[[Set]] ( _P_, _V_, _Receiver_)
+
When the [[Set]] internal method of an Integer Indexed exotic object _O_ is called with property key _P_, value _V_, and ECMAScript language value _Receiver_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. If Type(_P_) is String and if SameValue(_O_, _Receiver_) is *true*, then
+ 1. Let _numericIndex_ be CanonicalNumericIndexString(_P_).
+ 1. Assert: _numericIndex_ is not an abrupt completion.
+ 1. If _numericIndex_ is not *undefined*, then
+ 1. Return IntegerIndexedElementSet(_O_, _numericIndex_, _V_).
+ 1. Return the result of calling the default ordinary object [[Set]] internal method () on _O_ passing _P_, _V_, and _Receiver_ as arguments.
+
+
+
+
+
+
[[OwnPropertyKeys]] ()
+
When the [[OwnPropertyKeys]] internal method of an Integer Indexed exotic object _O_ is called the following steps are taken:
+
+ 1. Let _keys_ be a new empty List.
+ 1. Assert: _O_ is an Object that has [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] internal slots.
+ 1. Let _len_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. For each integer _i_ starting with 0 such that _i_ < _len_, in ascending order,
+ 1. Add ToString(_i_) as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ such that Type(_P_) is String and _P_ is not an integer index, in ascending chronological order of property creation
+ 1. Add _P_ as the last element of _keys_.
+ 1. For each own property key _P_ of _O_ such that Type(_P_) is Symbol, in ascending chronological order of property creation
+ 1. Add _P_ as the last element of _keys_.
+ 1. Return _keys_.
+
+
+
+
+
+
The abstract operation IntegerIndexedObjectCreate with arguments _prototype_ and _internalSlotsList_ is used to specify the creation of new Integer Indexed exotic objects. The argument _internalSlotsList_ is a List of the names of additional internal slots that must be defined as part of the object. IntegerIndexedObjectCreate performs the following steps:
+
+ 1. Assert: _internalSlotsList_ contains the names [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]].
+ 1. Let _A_ be a newly created object with an internal slot for each name in _internalSlotsList_.
+ 1. Set _A_'s essential internal methods to the default ordinary object definitions specified in .
+ 1. Set the [[GetOwnProperty]] internal method of _A_ as specified in .
+ 1. Set the [[HasProperty]] internal method of _A_ as specified in .
+ 1. Set the [[DefineOwnProperty]] internal method of _A_ as specified in .
+ 1. Set the [[Get]] internal method of _A_ as specified in .
+ 1. Set the [[Set]] internal method of _A_ as specified in .
+ 1. Set the [[OwnPropertyKeys]] internal method of _A_ as specified in .
+ 1. Set the [[Prototype]] internal slot of _A_ to _prototype_.
+ 1. Set the [[Extensible]] internal slot of _A_ to *true*.
+ 1. Return _A_.
+
+
+
+
+
+
IntegerIndexedElementGet ( _O_, _index_ )
+
The abstract operation IntegerIndexedElementGet with arguments _O_ and _index_ performs the following steps:
+
+ 1. Assert: Type(_index_) is Number.
+ 1. Assert: _O_ is an Object that has [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] internal slots.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. If IsInteger(_index_) is *false*, return *undefined*.
+ 1. If _index_ = -0, return *undefined*.
+ 1. Let _length_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. If _index_ < 0 or _index_ ≥ _length_, return *undefined*.
+ 1. Let _offset_ be the value of _O_'s [[ByteOffset]] internal slot.
+ 1. Let _arrayTypeName_ be the String value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for _arrayTypeName_.
+ 1. Let _indexedPosition_ be (_index_ × _elementSize_) + _offset_.
+ 1. Let _elementType_ be the String value of the Element Type value in for _arrayTypeName_.
+ 1. Return GetValueFromBuffer(_buffer_, _indexedPosition_, _elementType_).
+
+
+
+
+
+
The abstract operation IntegerIndexedElementSet with arguments _O_, _index_, and _value_ performs the following steps:
+
+ 1. Assert: Type(_index_) is Number.
+ 1. Assert: _O_ is an Object that has [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] internal slots.
+ 1. Let _numValue_ be ? ToNumber(_value_).
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. If IsInteger(_index_) is *false*, return *false*.
+ 1. If _index_ = -0, return *false*.
+ 1. Let _length_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. If _index_ < 0 or _index_ ≥ _length_, return *false*.
+ 1. Let _offset_ be the value of _O_'s [[ByteOffset]] internal slot.
+ 1. Let _arrayTypeName_ be the String value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for _arrayTypeName_.
+ 1. Let _indexedPosition_ be (_index_ × _elementSize_) + _offset_.
+ 1. Let _elementType_ be the String value of the Element Type value in for _arrayTypeName_.
+ 1. Perform SetValueInBuffer(_buffer_, _indexedPosition_, _elementType_, _numValue_).
+ 1. Return *true*.
+
+
+
+
+
+
+
Module Namespace Exotic Objects
+
A module namespace object is an exotic object that exposes the bindings exported from an ECMAScript |Module| (See ). There is a one-to-one correspondence between the String-keyed own properties of a module namespace exotic object and the binding names exported by the |Module|. The exported bindings include any bindings that are indirectly exported using `export *` export items. Each String-valued own property key is the StringValue of the corresponding exported binding name. These are the only String-keyed properties of a module namespace exotic object. Each such property has the attributes {[[Writable]]: *true*, [[Enumerable]]: *true*, [[Configurable]]: *false*}. Module namespace objects are not extensible.
+
Module namespace objects have the internal slots defined in .
+
+
+
+
+
+ Internal Slot
+
+
+ Type
+
+
+ Description
+
+
+
+
+ [[Module]]
+
+
+ Module Record
+
+
+ The Module Record whose exports this namespace exposes.
+
+
+
+
+ [[Exports]]
+
+
+ List of String
+
+
+ A List containing the String values of the exported names exposed as own properties of this object. The list is ordered as if an Array of those String values had been sorted using `Array.prototype.sort` using SortCompare as _comparefn_.
+
+
+
+
+
+
Module namespace exotic objects provide alternative definitions for all of the internal methods.
+
+
+
+
[[GetPrototypeOf]] ( )
+
When the [[GetPrototypeOf]] internal method of a module namespace exotic object _O_ is called the following steps are taken:
+
+ 1. Return *null*.
+
+
+
+
+
+
[[SetPrototypeOf]] (_V_)
+
When the [[SetPrototypeOf]] internal method of a module namespace exotic object _O_ is called with argument _V_ the following steps are taken:
+
+ 1. Assert: Either Type(_V_) is Object or Type(_V_) is Null.
+ 1. Return *false*.
+
+
+
+
+
+
[[IsExtensible]] ( )
+
When the [[IsExtensible]] internal method of a module namespace exotic object _O_ is called the following steps are taken:
+
+ 1. Return *false*.
+
+
+
+
+
+
[[PreventExtensions]] ( )
+
When the [[PreventExtensions]] internal method of a module namespace exotic object _O_ is called the following steps are taken:
+
+ 1. Return *true*.
+
+
+
+
+
+
[[GetOwnProperty]] (_P_)
+
When the [[GetOwnProperty]] internal method of a module namespace exotic object _O_ is called with property key _P_, the following steps are taken:
+
+ 1. If Type(_P_) is Symbol, return OrdinaryGetOwnProperty(_O_, _P_).
+ 1. Let _exports_ be the value of _O_'s [[Exports]] internal slot.
+ 1. If _P_ is not an element of _exports_, return *undefined*.
+ 1. Let _value_ be ? _O_.[[Get]](_P_, _O_).
+ 1. Return PropertyDescriptor{[[Value]]: _value_, [[Writable]]: *true*, [[Enumerable]]: *true*, [[Configurable]]: *false* }.
+
+
+
+
+
+
[[DefineOwnProperty]] (_P_, _Desc_)
+
When the [[DefineOwnProperty]] internal method of a module namespace exotic object _O_ is called with property key _P_ and Property Descriptor _Desc_, the following steps are taken:
+
+ 1. Return *false*.
+
+
+
+
+
+
[[HasProperty]] (_P_)
+
When the [[HasProperty]] internal method of a module namespace exotic object _O_ is called with property key _P_, the following steps are taken:
+
+ 1. If Type(_P_) is Symbol, return OrdinaryHasProperty(_O_, _P_).
+ 1. Let _exports_ be the value of _O_'s [[Exports]] internal slot.
+ 1. If _P_ is an element of _exports_, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
[[Get]] (_P_, _Receiver_)
+
When the [[Get]] internal method of a module namespace exotic object _O_ is called with property key _P_ and ECMAScript language value _Receiver_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. If Type(_P_) is Symbol, then
+ 1. Return the result of calling the default ordinary object [[Get]] internal method () on _O_ passing _P_ and _Receiver_ as arguments.
+ 1. Let _exports_ be the value of _O_'s [[Exports]] internal slot.
+ 1. If _P_ is not an element of _exports_, return *undefined*.
+ 1. Let _m_ be the value of _O_'s [[Module]] internal slot.
+ 1. Let _binding_ be ? _m_.ResolveExport(_P_, « », « »).
+ 1. Assert: _binding_ is neither *null* nor `"ambiguous"`.
+ 1. Let _targetModule_ be _binding_.[[module]].
+ 1. Assert: _targetModule_ is not *undefined*.
+ 1. Let _targetEnv_ be _targetModule_.[[Environment]].
+ 1. If _targetEnv_ is *undefined*, throw a *ReferenceError* exception.
+ 1. Let _targetEnvRec_ be _targetEnv_'s EnvironmentRecord.
+ 1. Return _targetEnvRec_.GetBindingValue(_binding_.[[bindingName]], *true*).
+
+
+
ResolveExport is idempotent and side-effect free. An implementation might choose to pre-compute or cache the ResolveExport results for the [[Exports]] of each module namespace exotic object.
+
+
+
+
+
+
[[Set]] ( _P_, _V_, _Receiver_)
+
When the [[Set]] internal method of a module namespace exotic object _O_ is called with property key _P_, value _V_, and ECMAScript language value _Receiver_, the following steps are taken:
+
+ 1. Return *false*.
+
+
+
+
+
+
[[Delete]] (_P_)
+
When the [[Delete]] internal method of a module namespace exotic object _O_ is called with property key _P_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _exports_ be the value of _O_'s [[Exports]] internal slot.
+ 1. If _P_ is an element of _exports_, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
[[Enumerate]] ()
+
When the [[Enumerate]] internal method of a module namespace exotic object _O_ is called the following steps are taken:
+
+ 1. Let _exports_ be the value of _O_'s [[Exports]] internal slot.
+ 1. Return CreateListIterator(_exports_).
+
+
+
+
+
+
[[OwnPropertyKeys]] ( )
+
When the [[OwnPropertyKeys]] internal method of a module namespace exotic object _O_ is called the following steps are taken:
+
+ 1. Let _exports_ be a copy of the value of _O_'s [[Exports]] internal slot.
+ 1. Let _symbolKeys_ be the result of calling the default ordinary object [[OwnPropertyKeys]] internal method () on _O_ passing no arguments.
+ 1. Append all the entries of _symbolKeys_ to the end of _exports_.
+ 1. Return _exports_.
+
+
+
+
+
+
ModuleNamespaceCreate (_module_, _exports_)
+
The abstract operation ModuleNamespaceCreate with arguments _module_, and _exports_ is used to specify the creation of new module namespace exotic objects. It performs the following steps:
+
+ 1. Assert: _module_ is a Module Record (see ).
+ 1. Assert: _module_.[[Namespace]] is *undefined*.
+ 1. Assert: _exports_ is a List of String values.
+ 1. Let _M_ be a newly created object.
+ 1. Set _M_'s essential internal methods to the definitions specified in .
+ 1. Set _M_'s [[Module]] internal slot to _module_.
+ 1. Set _M_'s [[Exports]] internal slot to _exports_.
+ 1. Create own properties of _M_ corresponding to the definitions in .
+ 1. Set _module_.[[Namespace]] to _M_.
+ 1. Return _M_.
+
+
+
+
+
+
+
+
Proxy Object Internal Methods and Internal Slots
+
A proxy object is an exotic object whose essential internal methods are partially implemented using ECMAScript code. Every proxy objects has an internal slot called [[ProxyHandler]]. The value of [[ProxyHandler]] is an object, called the proxy's handler object, or *null*. Methods (see ) of a handler object may be used to augment the implementation for one or more of the proxy object's internal methods. Every proxy object also has an internal slot called [[ProxyTarget]] whose value is either an object or the *null* value. This object is called the proxy's target object.
+
+
+
+
+
+ Internal Method
+
+
+ Handler Method
+
+
+
+
+ [[GetPrototypeOf]]
+
+
+ `getPrototypeOf`
+
+
+
+
+ [[SetPrototypeOf]]
+
+
+ `setPrototypeOf`
+
+
+
+
+ [[IsExtensible]]
+
+
+ `isExtensible`
+
+
+
+
+ [[PreventExtensions]]
+
+
+ `preventExtensions`
+
+
+
+
+ [[GetOwnProperty]]
+
+
+ `getOwnPropertyDescriptor`
+
+
+
+
+ [[HasProperty]]
+
+
+ `has`
+
+
+
+
+ [[Get]]
+
+
+ `get`
+
+
+
+
+ [[Set]]
+
+
+ `set`
+
+
+
+
+ [[Delete]]
+
+
+ `deleteProperty`
+
+
+
+
+ [[DefineOwnProperty]]
+
+
+ `defineProperty`
+
+
+
+
+ [[Enumerate]]
+
+
+ `enumerate`
+
+
+
+
+ [[OwnPropertyKeys]]
+
+
+ `ownKeys`
+
+
+
+
+ [[Call]]
+
+
+ `apply`
+
+
+
+
+ [[Construct]]
+
+
+ `construct`
+
+
+
+
+
+
When a handler method is called to provide the implementation of a proxy object internal method, the handler method is passed the proxy's target object as a parameter. A proxy's handler object does not necessarily have a method corresponding to every essential internal method. Invoking an internal method on the proxy results in the invocation of the corresponding internal method on the proxy's target object if the handler object does not have a method corresponding to the internal trap.
+
The [[ProxyHandler]] and [[ProxyTarget]] internal slots of a proxy object are always initialized when the object is created and typically may not be modified. Some proxy objects are created in a manner that permits them to be subsequently revoked. When a proxy is revoked, its [[ProxyHander]] and [[ProxyTarget]] internal slots are set to *null* causing subsequent invocations of internal methods on that proxy object to throw a *TypeError* exception.
+
Because proxy objects permit the implementation of internal methods to be provided by arbitrary ECMAScript code, it is possible to define a proxy object whose handler methods violates the invariants defined in . Some of the internal method invariants defined in are essential integrity invariants. These invariants are explicitly enforced by the proxy object internal methods specified in this section. An ECMAScript implementation must be robust in the presence of all possible invariant violations.
+
In the following algorithm descriptions, assume _O_ is an ECMAScript proxy object, _P_ is a property key value, _V_ is any ECMAScript language value and _Desc_ is a Property Descriptor record.
+
+
+
+
[[GetPrototypeOf]] ( )
+
When the [[GetPrototypeOf]] internal method of a Proxy exotic object _O_ is called the following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"getPrototypeOf"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[GetPrototypeOf]]().
+ 1. Let _handlerProto_ be ? Call(_trap_, _handler_, « _target_ »).
+ 1. If Type(_handlerProto_) is neither Object nor Null, throw a *TypeError* exception.
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. If _extensibleTarget_ is *true*, return _handlerProto_.
+ 1. Let _targetProto_ be ? _target_.[[GetPrototypeOf]]().
+ 1. If SameValue(_handlerProto_, _targetProto_) is *false*, throw a *TypeError* exception.
+ 1. Return _handlerProto_.
+
+
+
[[GetPrototypeOf]] for proxy objects enforces the following invariant:
+
+
+ The result of [[GetPrototypeOf]] must be either an Object or *null*.
+
+
+ If the target object is not extensible, [[GetPrototypeOf]] applied to the proxy object must return the same value as [[GetPrototypeOf]] applied to the proxy object's target object.
+
+
+
+
+
+
+
+
[[SetPrototypeOf]] (_V_)
+
When the [[SetPrototypeOf]] internal method of a Proxy exotic object _O_ is called with argument _V_ the following steps are taken:
+
+ 1. Assert: Either Type(_V_) is Object or Type(_V_) is Null.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"setPrototypeOf"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[SetPrototypeOf]](_V_).
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_, _V_ »)).
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. If _extensibleTarget_ is *true*, return _booleanTrapResult_.
+ 1. Let _targetProto_ be ? _target_.[[GetPrototypeOf]]().
+ 1. If _booleanTrapResult_ is *true* and SameValue(_V_, _targetProto_) is *false*, throw a *TypeError* exception.
+ 1. Return _booleanTrapResult_.
+
+
+
[[SetPrototypeOf]] for proxy objects enforces the following invariant:
+
+
+ The result of [[SetPrototypeOf]] is a Boolean value.
+
+
+ If the target object is not extensible, the argument value must be the same as the result of [[GetPrototypeOf]] applied to target object.
+
+
+
+
+
+
+
+
[[IsExtensible]] ( )
+
When the [[IsExtensible]] internal method of a Proxy exotic object _O_ is called the following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"isExtensible"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[IsExtensible]]().
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_ »)).
+ 1. Let _targetResult_ be ? _target_.[[IsExtensible]]().
+ 1. If SameValue(_booleanTrapResult_, _targetResult_) is *false*, throw a *TypeError* exception.
+ 1. Return _booleanTrapResult_.
+
+
+
[[IsExtensible]] for proxy objects enforces the following invariant:
+
+
+ The result of [[IsExtensible]] is a Boolean value.
+
+
+ [[IsExtensible]] applied to the proxy object must return the same value as [[IsExtensible]] applied to the proxy object's target object with the same argument.
+
+
+
+
+
+
+
+
[[PreventExtensions]] ( )
+
When the [[PreventExtensions]] internal method of a Proxy exotic object _O_ is called the following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"preventExtensions"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[PreventExtensions]]().
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_ »)).
+ 1. If _booleanTrapResult_ is *true*, then
+ 1. Let _targetIsExtensible_ be ? _target_.[[IsExtensible]]().
+ 1. If _targetIsExtensible_ is *true*, throw a *TypeError* exception.
+ 1. Return _booleanTrapResult_.
+
+
+
[[PreventExtensions]] for proxy objects enforces the following invariant:
+
+
+ The result of [[PreventExtensions]] is a Boolean value.
+
+
+ [[PreventExtensions]] applied to the proxy object only returns *true* if [[IsExtensible]] applied to the proxy object's target object is *false*.
+
+
+
+
+
+
+
+
[[GetOwnProperty]] (_P_)
+
When the [[GetOwnProperty]] internal method of a Proxy exotic object _O_ is called with property key _P_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"getOwnPropertyDescriptor"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[GetOwnProperty]](_P_).
+ 1. Let _trapResultObj_ be ? Call(_trap_, _handler_, « _target_, _P_ »).
+ 1. If Type(_trapResultObj_) is neither Object nor Undefined, throw a *TypeError* exception.
+ 1. Let _targetDesc_ be ? _target_.[[GetOwnProperty]](_P_).
+ 1. If _trapResultObj_ is *undefined*, then
+ 1. If _targetDesc_ is *undefined*, return *undefined*.
+ 1. If _targetDesc_.[[Configurable]] is *false*, throw a *TypeError* exception.
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. Assert: Type(_extensibleTarget_) is Boolean.
+ 1. If _extensibleTarget_ is *false*, throw a *TypeError* exception.
+ 1. Return *undefined*.
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. Let _resultDesc_ be ? ToPropertyDescriptor(_trapResultObj_).
+ 1. Call CompletePropertyDescriptor(_resultDesc_).
+ 1. Let _valid_ be IsCompatiblePropertyDescriptor(_extensibleTarget_, _resultDesc_, _targetDesc_).
+ 1. If _valid_ is *false*, throw a *TypeError* exception.
+ 1. If _resultDesc_.[[Configurable]] is *false*, then
+ 1. If _targetDesc_ is *undefined* or _targetDesc_.[[Configurable]] is *true*, then
+ 1. Throw a *TypeError* exception.
+ 1. Return _resultDesc_.
+
+
+
[[GetOwnProperty]] for proxy objects enforces the following invariants:
+
+
+ The result of [[GetOwnProperty]] must be either an Object or *undefined*.
+
+
+ A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.
+
+
+ A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible.
+
+
+ A property cannot be reported as existent, if it does not exists as an own property of the target object and the target object is not extensible.
+
+
+ A property cannot be reported as non-configurable, if it does not exists as an own property of the target object or if it exists as a configurable own property of the target object.
+
+
+
+
+
+
+
+
[[DefineOwnProperty]] (_P_, _Desc_)
+
When the [[DefineOwnProperty]] internal method of a Proxy exotic object _O_ is called with property key _P_ and Property Descriptor _Desc_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"defineProperty"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[DefineOwnProperty]](_P_, _Desc_).
+ 1. Let _descObj_ be FromPropertyDescriptor(_Desc_).
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_, _P_, _descObj_ »)).
+ 1. If _booleanTrapResult_ is *false*, return *false*.
+ 1. Let _targetDesc_ be ? _target_.[[GetOwnProperty]](_P_).
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. If _Desc_ has a [[Configurable]] field and if _Desc_.[[Configurable]] is *false*, then
+ 1. Let _settingConfigFalse_ be *true*.
+ 1. Else let _settingConfigFalse_ be *false*.
+ 1. If _targetDesc_ is *undefined*, then
+ 1. If _extensibleTarget_ is *false*, throw a *TypeError* exception.
+ 1. If _settingConfigFalse_ is *true*, throw a *TypeError* exception.
+ 1. Else _targetDesc_ is not *undefined*,
+ 1. If IsCompatiblePropertyDescriptor(_extensibleTarget_, _Desc_ , _targetDesc_) is *false*, throw a *TypeError* exception.
+ 1. If _settingConfigFalse_ is *true* and _targetDesc_.[[Configurable]] is *true*, throw a *TypeError* exception.
+ 1. Return *true*.
+
+
+
[[DefineOwnProperty]] for proxy objects enforces the following invariants:
+
+
+ The result of [[DefineOwnProperty]] is a Boolean value.
+
+
+ A property cannot be added, if the target object is not extensible.
+
+
+ A property cannot be non-configurable, unless there exists a corresponding non-configurable own property of the target object.
+
+
+ If a property has a corresponding target object property then applying the Property Descriptor of the property to the target object using [[DefineOwnProperty]] will not throw an exception.
+
+
+
+
+
+
+
+
[[HasProperty]] (_P_)
+
When the [[HasProperty]] internal method of a Proxy exotic object _O_ is called with property key _P_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"has"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[HasProperty]](_P_).
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_, _P_ »)).
+ 1. If _booleanTrapResult_ is *false*, then
+ 1. Let _targetDesc_ be ? _target_.[[GetOwnProperty]](_P_).
+ 1. If _targetDesc_ is not *undefined*, then
+ 1. If _targetDesc_.[[Configurable]] is *false*, throw a *TypeError* exception.
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. If _extensibleTarget_ is *false*, throw a *TypeError* exception.
+ 1. Return _booleanTrapResult_.
+
+
+
[[HasProperty]] for proxy objects enforces the following invariants:
+
+
+ The result of [[HasProperty]] is a Boolean value.
+
+
+ A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.
+
+
+ A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible.
+
+
+
+
+
+
+
+
[[Get]] (_P_, _Receiver_)
+
When the [[Get]] internal method of a Proxy exotic object _O_ is called with property key _P_ and ECMAScript language value _Receiver_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"get"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[Get]](_P_, _Receiver_).
+ 1. Let _trapResult_ be ? Call(_trap_, _handler_, « _target_, _P_, _Receiver_ »).
+ 1. Let _targetDesc_ be ? _target_.[[GetOwnProperty]](_P_).
+ 1. If _targetDesc_ is not *undefined*, then
+ 1. If IsDataDescriptor(_targetDesc_) and _targetDesc_.[[Configurable]] is *false* and _targetDesc_.[[Writable]] is *false*, then
+ 1. If SameValue(_trapResult_, _targetDesc_.[[Value]]) is *false*, throw a *TypeError* exception.
+ 1. If IsAccessorDescriptor(_targetDesc_) and _targetDesc_.[[Configurable]] is *false* and _targetDesc_.[[Get]] is *undefined*, then
+ 1. If _trapResult_ is not *undefined*, throw a *TypeError* exception.
+ 1. Return _trapResult_.
+
+
+
[[Get]] for proxy objects enforces the following invariants:
+
+
+ The value reported for a property must be the same as the value of the corresponding target object property if the target object property is a non-writable, non-configurable own data property.
+
+
+ The value reported for a property must be *undefined* if the corresponding target object property is a non-configurable own accessor property that has *undefined* as its [[Get]] attribute.
+
+
+
+
+
+
+
+
[[Set]] ( _P_, _V_, _Receiver_)
+
When the [[Set]] internal method of a Proxy exotic object _O_ is called with property key _P_, value _V_, and ECMAScript language value _Receiver_, the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"set"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[Set]](_P_, _V_, _Receiver_).
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_, _P_, _V_, _Receiver_ »)).
+ 1. If _booleanTrapResult_ is *false*, return *false*.
+ 1. Let _targetDesc_ be ? _target_.[[GetOwnProperty]](_P_).
+ 1. If _targetDesc_ is not *undefined*, then
+ 1. If IsDataDescriptor(_targetDesc_) and _targetDesc_.[[Configurable]] is *false* and _targetDesc_.[[Writable]] is *false*, then
+ 1. If SameValue(_V_, _targetDesc_.[[Value]]) is *false*, throw a *TypeError* exception.
+ 1. If IsAccessorDescriptor(_targetDesc_) and _targetDesc_.[[Configurable]] is *false*, then
+ 1. If _targetDesc_.[[Set]] is *undefined*, throw a *TypeError* exception.
+ 1. Return *true*.
+
+
+
[[Set]] for proxy objects enforces the following invariants:
+
+
+ The result of [[Set]] is a Boolean value.
+
+
+ Cannot change the value of a property to be different from the value of the corresponding target object property if the corresponding target object property is a non-writable, non-configurable own data property.
+
+
+ Cannot set the value of a property if the corresponding target object property is a non-configurable own accessor property that has *undefined* as its [[Set]] attribute.
+
+
+
+
+
+
+
+
[[Delete]] (_P_)
+
When the [[Delete]] internal method of a Proxy exotic object _O_ is called with property key _P_ the following steps are taken:
+
+ 1. Assert: IsPropertyKey(_P_) is *true*.
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"deleteProperty"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[Delete]](_P_).
+ 1. Let _booleanTrapResult_ be ToBoolean(? Call(_trap_, _handler_, « _target_, _P_ »)).
+ 1. If _booleanTrapResult_ is *false*, return *false*.
+ 1. Let _targetDesc_ be ? _target_.[[GetOwnProperty]](_P_).
+ 1. If _targetDesc_ is *undefined*, return *true*.
+ 1. If _targetDesc_.[[Configurable]] is *false*, throw a *TypeError* exception.
+ 1. Return *true*.
+
+
+
[[Delete]] for proxy objects enforces the following invariant:
+
+
+ The result of [[Delete]] is a Boolean value.
+
+
+ A property cannot be reported as deleted, if it exists as a non-configurable own property of the target object.
+
+
+
+
+
+
+
+
[[Enumerate]] ()
+
When the [[Enumerate]] internal method of a Proxy exotic object _O_ is called the following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"enumerate"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[Enumerate]]().
+ 1. Let _trapResult_ be ? Call(_trap_, _handler_, « _target_ »).
+ 1. If Type(_trapResult_) is not Object, throw a *TypeError* exception.
+ 1. Return _trapResult_.
+
+
+
[[Enumerate]] for proxy objects enforces the following invariants:
+
+
+ The result of [[Enumerate]] must be an Object.
+
+
+
+
+
+
+
+
[[OwnPropertyKeys]] ( )
+
When the [[OwnPropertyKeys]] internal method of a Proxy exotic object _O_ is called the following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"ownKeys"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return _target_.[[OwnPropertyKeys]]().
+ 1. Let _trapResultArray_ be Call(_trap_, _handler_, « _target_ »).
+ 1. Let _trapResult_ be ? CreateListFromArrayLike(_trapResultArray_, « String, Symbol »).
+ 1. Let _extensibleTarget_ be ? IsExtensible(_target_).
+ 1. Let _targetKeys_ be ? _target_.[[OwnPropertyKeys]]().
+ 1. Assert: _targetKeys_ is a List containing only String and Symbol values.
+ 1. Let _targetConfigurableKeys_ be an empty List.
+ 1. Let _targetNonconfigurableKeys_ be an empty List.
+ 1. Repeat, for each element _key_ of _targetKeys_,
+ 1. Let _desc_ be ? _target_.[[GetOwnProperty]](_key_).
+ 1. If _desc_ is not *undefined* and _desc_.[[Configurable]] is *false*, then
+ 1. Append _key_ as an element of _targetNonconfigurableKeys_.
+ 1. Else,
+ 1. Append _key_ as an element of _targetConfigurableKeys_.
+ 1. If _extensibleTarget_ is *true* and _targetNonconfigurableKeys_ is empty, then
+ 1. Return _trapResult_.
+ 1. Let _uncheckedResultKeys_ be a new List which is a copy of _trapResult_.
+ 1. Repeat, for each _key_ that is an element of _targetNonconfigurableKeys_,
+ 1. If _key_ is not an element of _uncheckedResultKeys_, throw a *TypeError* exception.
+ 1. Remove _key_ from _uncheckedResultKeys_.
+ 1. If _extensibleTarget_ is *true*, return _trapResult_.
+ 1. Repeat, for each _key_ that is an element of _targetConfigurableKeys_,
+ 1. If _key_ is not an element of _uncheckedResultKeys_, throw a *TypeError* exception.
+ 1. Remove _key_ from _uncheckedResultKeys_.
+ 1. If _uncheckedResultKeys_ is not empty, throw a *TypeError* exception.
+ 1. Return _trapResult_.
+
+
+
[[OwnPropertyKeys]] for proxy objects enforces the following invariants:
+
+
+ The result of [[OwnPropertyKeys]] is a List.
+
+
+ The Type of each result List element is either String or Symbol.
+
+
+ The result List must contain the keys of all non-configurable own properties of the target object.
+
+
+ If the target object is not extensible, then the result List must contain all the keys of the own properties of the target object and no other values.
+
+
+
+
+
+
+
+
[[Call]] (_thisArgument_, _argumentsList_)
+
The [[Call]] internal method of a Proxy exotic object _O_ is called with parameters _thisArgument_ and _argumentsList_, a List of ECMAScript language values. The following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"apply"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Return Call(_target_, _thisArgument_, _argumentsList_).
+ 1. Let _argArray_ be CreateArrayFromList(_argumentsList_).
+ 1. Return Call(_trap_, _handler_, « _target_, _thisArgument_, _argArray_ »).
+
+
+
A Proxy exotic object only has a [[Call]] internal method if the initial value of its [[ProxyTarget]] internal slot is an object that has a [[Call]] internal method.
+
+
+
+
+
+
[[Construct]] ( _argumentsList_, _newTarget_)
+
The [[Construct]] internal method of a Proxy exotic object _O_ is called with parameters _argumentsList_ which is a possibly empty List of ECMAScript language values and _newTarget_. The following steps are taken:
+
+ 1. Let _handler_ be the value of the [[ProxyHandler]] internal slot of _O_.
+ 1. If _handler_ is *null*, throw a *TypeError* exception.
+ 1. Assert: Type(_handler_) is Object.
+ 1. Let _target_ be the value of the [[ProxyTarget]] internal slot of _O_.
+ 1. Let _trap_ be ? GetMethod(_handler_, `"construct"`).
+ 1. If _trap_ is *undefined*, then
+ 1. Assert: _target_ has a [[Construct]] internal method.
+ 1. Return Construct(_target_, _argumentsList_, _newTarget_).
+ 1. Let _argArray_ be CreateArrayFromList(_argumentsList_).
+ 1. Let _newObj_ be ? Call(_trap_, _handler_, « _target_, _argArray_, _newTarget_ »).
+ 1. If Type(_newObj_) is not Object, throw a *TypeError* exception.
+ 1. Return _newObj_.
+
+
+
A Proxy exotic object only has a [[Construct]] internal method if the initial value of its [[ProxyTarget]] internal slot is an object that has a [[Construct]] internal method.
+
+
+
[[Construct]] for proxy objects enforces the following invariants:
+
+
+ The result of [[Construct]] must be an Object.
+
+
+
+
+
+
+
+
ProxyCreate(_target_, _handler_)
+
The abstract operation ProxyCreate with arguments _target_ and _handler_ is used to specify the creation of new Proxy exotic objects. It performs the following steps:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. If _target_ is a Proxy exotic object and the value of the [[ProxyHandler]] internal slot of _target_ is *null*, throw a *TypeError* exception.
+ 1. If Type(_handler_) is not Object, throw a *TypeError* exception.
+ 1. If _handler_ is a Proxy exotic object and the value of the [[ProxyHandler]] internal slot of _handler_ is *null*, throw a *TypeError* exception.
+ 1. Let _P_ be a newly created object.
+ 1. Set _P_'s essential internal methods (except for [[Call]] and [[Construct]]) to the definitions specified in .
+ 1. If IsCallable(_target_) is *true*, then
+ 1. Set the [[Call]] internal method of _P_ as specified in .
+ 1. If _target_ has a [[Construct]] internal method, then
+ 1. Set the [[Construct]] internal method of _P_ as specified in .
+ 1. Set the [[ProxyTarget]] internal slot of _P_ to _target_.
+ 1. Set the [[ProxyHandler]] internal slot of _P_ to _handler_.
+ 1. Return _P_.
+
+
+
+
+
+
+
+
ECMAScript Language: Source Code
+
+
+
+
Source Text
+
Syntax
+
+ SourceCharacter ::
+ > any Unicode code point
+
+
ECMAScript code is expressed using Unicode, version 5.1 or later. ECMAScript source text is a sequence of code points. All Unicode code point values from U+0000 to U+10FFFF, including surrogate code points, may occur in source text where permitted by the ECMAScript grammars. The actual encodings used to store and interchange ECMAScript source text is not relevant to this specification. Regardless of the external source text encoding, a conforming ECMAScript implementation processes the source text as if it was an equivalent sequence of |SourceCharacter| values. Each |SourceCharacter| being a Unicode code point. Conforming ECMAScript implementations are not required to perform any normalization of source text, or behave as though they were performing normalization of source text.
+
The components of a combining character sequence are treated as individual Unicode code points even though a user might think of the whole sequence as a single character.
+
+
In string literals, regular expression literals, template literals and identifiers, any Unicode code point may also be expressed using Unicode escape sequences that explicitly express a code point's numeric value. Within a comment, such an escape sequence is effectively ignored as part of the comment.
+
ECMAScript differs from the Java programming language in the behaviour of Unicode escape sequences. In a Java program, if the Unicode escape sequence `\\u000A`, for example, occurs within a single-line comment, it is interpreted as a line terminator (Unicode code point U+000A is LINE FEED (LF)) and therefore the next code point is not part of the comment. Similarly, if the Unicode escape sequence `\\u000A` occurs within a string literal in a Java program, it is likewise interpreted as a line terminator, which is not allowed within a string literal—one must write `\\n` instead of `\\u000A` to cause a LINE FEED (LF) to be part of the String value of a string literal. In an ECMAScript program, a Unicode escape sequence occurring within a comment is never interpreted and therefore cannot contribute to termination of the comment. Similarly, a Unicode escape sequence occurring within a string literal in an ECMAScript program always contributes to the literal and is never interpreted as a line terminator or as a code point that might terminate the string literal.
+
+
+
+
+
Static Semantics: UTF16Encoding ( _cp_ )
+
The UTF16Encoding of a numeric code point value, _cp_, is determined as follows:
+
+ 1. Assert: 0 ≤ _cp_ ≤ 0x10FFFF.
+ 1. If _cp_ ≤ 65535, return _cp_.
+ 1. Let _cu1_ be floor((_cp_ - 65536) / 1024) + 0xD800.
+ 1. Let _cu2_ be ((_cp_ - 65536) modulo 1024) + 0xDC00.
+ 1. Return the code unit sequence consisting of _cu1_ followed by _cu2_.
+
+
+
+
+
+
Static Semantics: UTF16Decode( _lead_, _trail_ )
+
Two code units, _lead_ and _trail_, that form a UTF-16 surrogate pair are converted to a code point by performing the following steps:
+
+ 1. Assert: 0xD800 ≤ _lead_ ≤ 0xDBFF and 0xDC00 ≤ _trail_ ≤ 0xDFFF.
+ 1. Let _cp_ be (_lead_ - 0xD800) × 1024 + (_trail_ - 0xDC00) + 0x10000.
+ 1. Return the code point _cp_.
+
+
+
+
+
+
+
Types of Source Code
+
There are four types of ECMAScript code:
+
+
+ Global code is source text that is treated as an ECMAScript |Script|. The global code of a particular |Script| does not include any source text that is parsed as part of a |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |MethodDefinition|, |ArrowFunction|, |ClassDeclaration|, or |ClassExpression|.
+
+
+ Eval code is the source text supplied to the built-in `eval` function. More precisely, if the parameter to the built-in `eval` function is a String, it is treated as an ECMAScript |Script|. The eval code for a particular invocation of `eval` is the global code portion of that |Script|.
+
+
+ Function code is source text that is parsed to supply the value of the [[ECMAScriptCode]] and [[FormalParameters]] internal slots (see ) of an ECMAScript function object. The function code of a particular ECMAScript function does not include any source text that is parsed as the function code of a nested |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |MethodDefinition|, |ArrowFunction|, |ClassDeclaration|, or |ClassExpression|.
+
+
+ Module code is source text that is code that is provided as a |ModuleBody|. It is the code that is directly evaluated when a module is initialized. The module code of a particular module does not include any source text that is parsed as part of a nested |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |MethodDefinition|, |ArrowFunction|, |ClassDeclaration|, or |ClassExpression|.
+
+
+
+
Function code is generally provided as the bodies of Function Definitions (), Arrow Function Definitions (), Method Definitions () and Generator Definitions (). Function code is also derived from the arguments to the `Function` constructor () and the GeneratorFunction constructor ().
+
+
+
+
+
Strict Mode Code
+
An ECMAScript |Script| syntactic unit may be processed using either unrestricted or strict mode syntax and semantics. Code is interpreted as strict mode code in the following situations:
+
+
+ Global code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive (see ).
+
+
+ Module code is always strict mode code.
+
+
+ All parts of a |ClassDeclaration| or a |ClassExpression| are strict mode code.
+
+
+ Eval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to eval is a direct eval (see ) that is contained in strict mode code.
+
+
+ Function code is strict mode code if the associated |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |MethodDefinition|, or |ArrowFunction| is contained in strict mode code or if the code that produces the value of the function's [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.
+
+
+ Function code that is supplied as the arguments to the built-in `Function` and `Generator` constructors is strict mode code if the last argument is a String that when processed is a |FunctionBody| that begins with a Directive Prologue that contains a Use Strict Directive.
+
+
+
ECMAScript code that is not strict mode code is called non-strict code.
+
+
+
+
+
Non-ECMAScript Functions
+
An ECMAScript implementation may support the evaluation of exotic function objects whose evaluative behaviour is expressed in some implementation defined form of executable code other than via ECMAScript code. Whether a function object is an ECMAScript code function or a non-ECMAScript function is not semantically observable from the perspective of an ECMAScript code function that calls or is called by such a non-ECMAScript function.
+
+
+
+
+
+
+
ECMAScript Language: Lexical Grammar
+
The source text of an ECMAScript |Script| or |Module| is first converted into a sequence of input elements, which are tokens, line terminators, comments, or white space. The source text is scanned from left to right, repeatedly taking the longest possible sequence of code points as the next input element.
+
There are several situations where the identification of lexical input elements is sensitive to the syntactic grammar context that is consuming the input elements. This requires multiple goal symbols for the lexical grammar. The |InputElementRegExpOrTemplateTail| goal is used in syntactic grammar contexts where a |RegularExpressionLiteral|, a |TemplateMiddle|, or a |TemplateTail| is permitted. The |InputElementRegExp| goal symbol is used in all syntactic grammar contexts where a |RegularExpressionLiteral| is permitted but neither a |TemplateMiddle|, nor a |TemplateTail| is permitted. The |InputElementTemplateTail| goal is used in all syntactic grammar contexts where a |TemplateMiddle| or a |TemplateTail| is permitted but a |RegularExpressionLiteral| is not permitted. In all other contexts, |InputElementDiv| is used as the lexical goal symbol.
+
+
The use of multiple lexical goals ensures that there are no lexical ambiguities that would affect automatic semicolon insertion. For example, there are no syntactic grammar contexts where both a leading division or division-assignment, and a leading |RegularExpressionLiteral| are permitted. This is not affected by semicolon insertion (see ); in examples such as the following:
+
+a = b
+/hi/g.exec(c).map(d);
+
+
where the first non-whitespace, non-comment code point after a |LineTerminator| is U+002F (SOLIDUS) and the syntactic context allows division or division-assignment, no semicolon is inserted at the |LineTerminator|. That is, the above example is interpreted in the same way as:
The Unicode format-control characters (i.e., the characters in category “Cf” in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT MARK) are control codes used to control the formatting of a range of text in the absence of higher-level protocols for this (such as mark-up languages).
+
It is useful to allow format-control characters in source text to facilitate editing and display. All format control characters may be used within comments, and within string literals, template literals, and regular expression literals.
+
U+200C (ZERO WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER) are format-control characters that are used to make necessary distinctions when forming words or phrases in certain languages. In ECMAScript source text these code points may also be used in an |IdentifierName| (see ) after the first character.
+
U+FEFF (ZERO WIDTH NO-BREAK SPACE) is a format-control character used primarily at the start of a text to mark it as Unicode and to allow detection of the text's encoding and byte order. <ZWNBSP> characters intended for this purpose can sometimes also appear after the start of a text, for example as a result of concatenating files. In ECMAScript source text <ZWNBSP> code points are treated as white space characters (see ).
+
The special treatment of certain format-control characters outside of comments, string literals, and regular expression literals is summarized in .
+
+
+
+
+
+ Code Point
+
+
+ Name
+
+
+ Abbreviation
+
+
+ Usage
+
+
+
+
+ `U+200C`
+
+
+ ZERO WIDTH NON-JOINER
+
+
+ <ZWNJ>
+
+
+ |IdentifierPart|
+
+
+
+
+ `U+200D`
+
+
+ ZERO WIDTH JOINER
+
+
+ <ZWJ>
+
+
+ |IdentifierPart|
+
+
+
+
+ `U+FEFF`
+
+
+ ZERO WIDTH NO-BREAK SPACE
+
+
+ <ZWNBSP>
+
+
+ |WhiteSpace|
+
+
+
+
+
+
+
+
+
+
White Space
+
White space code points are used to improve source text readability and to separate tokens (indivisible lexical units) from each other, but are otherwise insignificant. White space code points may occur between any two tokens and at the start or end of input. White space code points may occur within a |StringLiteral|, a |RegularExpressionLiteral|, a |Template|, or a |TemplateSubstitutionTail| where they are considered significant code points forming part of a literal value. They may also occur within a |Comment|, but cannot appear within any other kind of token.
+
The ECMAScript white space code points are listed in .
+
+
+
+
+
+ Code Point
+
+
+ Name
+
+
+ Abbreviation
+
+
+
+
+ `U+0009`
+
+
+ CHARACTER TABULATION
+
+
+ <TAB>
+
+
+
+
+ `U+000B`
+
+
+ LINE TABULATION
+
+
+ <VT>
+
+
+
+
+ `U+000C`
+
+
+ FORM FEED (FF)
+
+
+ <FF>
+
+
+
+
+ `U+0020`
+
+
+ SPACE
+
+
+ <SP>
+
+
+
+
+ `U+00A0`
+
+
+ NO-BREAK SPACE
+
+
+ <NBSP>
+
+
+
+
+ `U+FEFF`
+
+
+ ZERO WIDTH NO-BREAK SPACE
+
+
+ <ZWNBSP>
+
+
+
+
+ Other category “Zs”
+
+
+ Any other Unicode “Separator, space” code point
+
+
+ <USP>
+
+
+
+
+
+
ECMAScript implementations must recognize as |WhiteSpace| code points listed in the “Separator, space” (Zs) category by Unicode 5.1. ECMAScript implementations may also recognize as |WhiteSpace| additional category Zs code points from subsequent editions of the Unicode Standard.
+
+
Other than for the code points listed in , ECMAScript |WhiteSpace| intentionally excludes all code points that have the Unicode “White_Space” property but which are not classified in category “Zs”.
Like white space code points, line terminator code points are used to improve source text readability and to separate tokens (indivisible lexical units) from each other. However, unlike white space code points, line terminators have some influence over the behaviour of the syntactic grammar. In general, line terminators may occur between any two tokens, but there are a few places where they are forbidden by the syntactic grammar. Line terminators also affect the process of automatic semicolon insertion (). A line terminator cannot occur within any token except a |StringLiteral|, |Template|, or |TemplateSubstitutionTail|. Line terminators may only occur within a |StringLiteral| token as part of a |LineContinuation|.
+
A line terminator can occur within a |MultiLineComment| () but cannot occur within a |SingleLineComment|.
+
Line terminators are included in the set of white space code points that are matched by the `\\s` class in regular expressions.
+
The ECMAScript line terminator code points are listed in .
+
+
+
+
+
+ Code Point
+
+
+ Unicode Name
+
+
+ Abbreviation
+
+
+
+
+ `U+000A`
+
+
+ LINE FEED (LF)
+
+
+ <LF>
+
+
+
+
+ `U+000D`
+
+
+ CARRIAGE RETURN (CR)
+
+
+ <CR>
+
+
+
+
+ `U+2028`
+
+
+ LINE SEPARATOR
+
+
+ <LS>
+
+
+
+
+ `U+2029`
+
+
+ PARAGRAPH SEPARATOR
+
+
+ <PS>
+
+
+
+
+
+
Only the Unicode code points in are treated as line terminators. Other new line or line breaking Unicode code points are not treated as line terminators but are treated as white space if they meet the requirements listed in . The sequence <CR><LF> is commonly used as a line terminator. It should be considered a single |SourceCharacter| for the purpose of reporting line numbers.
Comments can be either single or multi-line. Multi-line comments cannot nest.
+
Because a single-line comment can contain any Unicode code point except a |LineTerminator| code point, and because of the general rule that a token is always as long as possible, a single-line comment always consists of all code points from the `//` marker to the end of the line. However, the |LineTerminator| at the end of the line is not considered to be part of the single-line comment; it is recognized separately by the lexical grammar and becomes part of the stream of input elements for the syntactic grammar. This point is very important, because it implies that the presence or absence of single-line comments does not affect the process of automatic semicolon insertion (see ).
+
Comments behave like white space and are discarded except that, if a |MultiLineComment| contains a line terminator code point, then the entire comment is considered to be a |LineTerminator| for purposes of parsing by the syntactic grammar.
+
Syntax
+
+ Comment ::
+ MultiLineComment
+ SingleLineComment
+
+ MultiLineComment ::
+ `/*` MultiLineCommentChars? `*/`
+
+ MultiLineCommentChars ::
+ MultiLineNotAsteriskChar MultiLineCommentChars?
+ `*` PostAsteriskCommentChars?
+
+ PostAsteriskCommentChars ::
+ MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentChars?
+ `*` PostAsteriskCommentChars?
+
+ MultiLineNotAsteriskChar ::
+ SourceCharacter but not `*`
+
+ MultiLineNotForwardSlashOrAsteriskChar ::
+ SourceCharacter but not one of `/` or `*`
+
+ SingleLineComment ::
+ `//` SingleLineCommentChars?
+
+ SingleLineCommentChars ::
+ SingleLineCommentChar SingleLineCommentChars?
+
+ SingleLineCommentChar ::
+ SourceCharacter but not LineTerminator
+
+
+
+
+
+
The |DivPunctuator|, |RegularExpressionLiteral|, |RightBracePunctuator|, and |TemplateSubstitutionTail| productions derive additional tokens that are not included in the |CommonToken| production.
+
+
+
+
+
+
Names and Keywords
+
|IdentifierName| and |ReservedWord| are tokens that are interpreted according to the Default Identifier Syntax given in Unicode Standard Annex #31, Identifier and Pattern Syntax, with some small modifications. |ReservedWord| is an enumerated subset of |IdentifierName|. The syntactic grammar defines |Identifier| as an |IdentifierName| that is not a |ReservedWord| (see ). The Unicode identifier grammar is based on character properties specified by the Unicode Standard. The Unicode code points in the specified categories in version 5.1.0 of the Unicode standard must be treated as in those categories by all conforming ECMAScript implementations. ECMAScript implementations may recognize identifier code points defined in later editions of the Unicode Standard.
+
+
This standard specifies specific code point additions: U+0024 (DOLLAR SIGN) and U+005F (LOW LINE) are permitted anywhere in an |IdentifierName|, and the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER) are permitted anywhere after the first code point of an |IdentifierName|.
+
+
Unicode escape sequences are permitted in an |IdentifierName|, where they contribute a single Unicode code point to the |IdentifierName|. The code point is expressed by the |HexDigits| of the |UnicodeEscapeSequence| (see ). The `\\` preceding the |UnicodeEscapeSequence| and the `u` and `{ }` code units, if they appear, do not contribute code points to the |IdentifierName|. A |UnicodeEscapeSequence| cannot be used to put a code point into an |IdentifierName| that would otherwise be illegal. In other words, if a `\\` |UnicodeEscapeSequence| sequence were replaced by the |SourceCharacter| it contributes, the result must still be a valid |IdentifierName| that has the exact same sequence of |SourceCharacter| elements as the original |IdentifierName|. All interpretations of |IdentifierName| within this specification are based upon their actual code points regardless of whether or not an escape sequence was used to contribute any particular code point.
+
Two |IdentifierName| that are canonically equivalent according to the Unicode standard are not equal unless, after replacement of each |UnicodeEscapeSequence|, they are represented by the exact same sequence of code points.
+
Syntax
+
+ IdentifierName ::
+ IdentifierStart
+ IdentifierName IdentifierPart
+
+ IdentifierStart ::
+ UnicodeIDStart
+ `$`
+ `_`
+ `\` UnicodeEscapeSequence
+
+ IdentifierPart ::
+ UnicodeIDContinue
+ `$`
+ `_`
+ `\` UnicodeEscapeSequence
+ <ZWNJ>
+ <ZWJ>
+
+ UnicodeIDStart ::
+ > any Unicode code point with the Unicode property “ID_Start”
+
+ UnicodeIDContinue ::
+ > any Unicode code point with the Unicode property “ID_Continue”
+
+
The definitions of the nonterminal |UnicodeEscapeSequence| is given in .
+
+
The sets of code points with Unicode properties “ID_Start” and “ID_Continue” include, respectively, the code points with Unicode properties “Other_ID_Start” and “Other_ID_Continue”.
+
+
+
+
+
Identifier Names
+
+
+
+
Static Semantics: Early Errors
+ IdentifierStart :: `\` UnicodeEscapeSequence
+
+
+ It is a Syntax Error if SV(|UnicodeEscapeSequence|) is none of `"$"`, or `"_"`, or the UTF16Encoding () of a code point matched by the |UnicodeIDStart| lexical grammar production.
+
+
+ IdentifierPart :: `\` UnicodeEscapeSequence
+
+
+ It is a Syntax Error if SV(|UnicodeEscapeSequence|) is none of `"$"`, or `"_"`, or the UTF16Encoding () of either <ZWNJ> or <ZWJ>, or the UTF16Encoding of a Unicode code point that would be matched by the |UnicodeIDContinue| lexical grammar production.
+
+
+
+
+
+
+
Static Semantics: StringValue
+
+
+ IdentifierName ::
+ IdentifierStart
+ IdentifierName IdentifierPart
+
+
+ 1. Return the String value consisting of the sequence of code units corresponding to |IdentifierName|. In determining the sequence any occurrences of `\\` |UnicodeEscapeSequence| are first replaced with the code point represented by the |UnicodeEscapeSequence| and then the code points of the entire |IdentifierName| are converted to code units by UTF16Encoding () each code point.
+
+
+
+
+
+
+
Reserved Words
+
A reserved word is an |IdentifierName| that cannot be used as an |Identifier|.
The |ReservedWord| definitions are specified as literal sequences of specific |SourceCharacter| elements. A code point in a |ReservedWord| cannot be expressed by a `\\` |UnicodeEscapeSequence|.
+
+
+
+
+
Keywords
+
The following tokens are ECMAScript keywords and may not be used as |Identifier|s in ECMAScript programs.
In some contexts `yield` is given the semantics of an |Identifier|. See . In strict mode code, `let` and `static` are treated as reserved keywords through static semantic restrictions (see , , , and ) rather than the lexical grammar.
+
+
+
+
+
+
Future Reserved Words
+
The following tokens are reserved for used as keywords in future language extensions.
+
Syntax
+
+ FutureReservedWord ::
+ `enum`
+ `await`
+
+
`await` is only treated as a |FutureReservedWord| when |Module| is the goal symbol of the syntactic grammar.
+
+
Use of the following tokens within strict mode code (see ) is also reserved. That usage is restricted using static semantic restrictions (see ) rather than the lexical grammar:
The |SourceCharacter| immediately following a |NumericLiteral| must not be an |IdentifierStart| or |DecimalDigit|.
+
+
For example: `3in` is an error and not the two input elements `3` and `in`.
+
+
A conforming implementation, when processing strict mode code (see ), must not extend, as described in , the syntax of |NumericLiteral| to include |LegacyOctalIntegerLiteral|, nor extend the syntax of |DecimalIntegerLiteral| to include |NonOctalDecimalIntegerLiteral|.
+
+
+
+
Static Semantics: MV
+
A numeric literal stands for a value of the Number type. This value is determined in two steps: first, a mathematical value (MV) is derived from the literal; second, this mathematical value is rounded as described below.
+
+
+ The MV of NumericLiteral :: DecimalLiteral is the MV of |DecimalLiteral|.
+
+
+ The MV of NumericLiteral :: BinaryIntegerLiteral is the MV of |BinaryIntegerLiteral|.
+
+
+ The MV of NumericLiteral :: OctalIntegerLiteral is the MV of |OctalIntegerLiteral|.
+
+
+ The MV of NumericLiteral :: HexIntegerLiteral is the MV of |HexIntegerLiteral|.
+
+
+ The MV of DecimalLiteral :: DecimalIntegerLiteral `.` is the MV of |DecimalIntegerLiteral|.
+
+
+ The MV of DecimalLiteral :: DecimalIntegerLiteral `.` DecimalDigits is the MV of |DecimalIntegerLiteral| plus (the MV of |DecimalDigits| × 10-_n_), where _n_ is the number of code points in |DecimalDigits|.
+
+
+ The MV of DecimalLiteral :: DecimalIntegerLiteral `.` ExponentPart is the MV of |DecimalIntegerLiteral| × 10_e_, where _e_ is the MV of |ExponentPart|.
+
+
+ The MV of DecimalLiteral :: DecimalIntegerLiteral `.` DecimalDigits ExponentPart is (the MV of |DecimalIntegerLiteral| plus (the MV of |DecimalDigits| × 10-_n_)) × 10_e_, where _n_ is the number of code points in |DecimalDigits| and _e_ is the MV of |ExponentPart|.
+
+
+ The MV of DecimalLiteral :: `.` DecimalDigits is the MV of |DecimalDigits| × 10-_n_, where _n_ is the number of code points in |DecimalDigits|.
+
+
+ The MV of DecimalLiteral :: `.` DecimalDigits ExponentPart is the MV of |DecimalDigits| × 10_e_-_n_, where _n_ is the number of code points in |DecimalDigits| and _e_ is the MV of |ExponentPart|.
+
+
+ The MV of DecimalLiteral :: DecimalIntegerLiteral is the MV of |DecimalIntegerLiteral|.
+
+
+ The MV of DecimalLiteral :: DecimalIntegerLiteral ExponentPart is the MV of |DecimalIntegerLiteral| × 10_e_, where _e_ is the MV of |ExponentPart|.
+
+
+ The MV of DecimalIntegerLiteral :: `0` is 0.
+
+
+ The MV of DecimalIntegerLiteral :: NonZeroDigit is the MV of |NonZeroDigit|.
+
+
+ The MV of DecimalIntegerLiteral :: NonZeroDigit DecimalDigits is (the MV of |NonZeroDigit| × 10_n_) plus the MV of |DecimalDigits|, where _n_ is the number of code points in |DecimalDigits|.
+
+
+ The MV of DecimalDigits :: DecimalDigit is the MV of |DecimalDigit|.
+
+
+ The MV of DecimalDigits :: DecimalDigits DecimalDigit is (the MV of |DecimalDigits| × 10) plus the MV of |DecimalDigit|.
+
+
+ The MV of ExponentPart :: ExponentIndicator SignedInteger is the MV of |SignedInteger|.
+
+
+ The MV of SignedInteger :: DecimalDigits is the MV of |DecimalDigits|.
+
+
+ The MV of SignedInteger :: `+` DecimalDigits is the MV of |DecimalDigits|.
+
+
+ The MV of SignedInteger :: `-` DecimalDigits is the negative of the MV of |DecimalDigits|.
+
+
+ The MV of DecimalDigit :: `0` or of HexDigit :: `0` or of OctalDigit :: `0` or of BinaryDigit :: `0` is 0.
+
+
+ The MV of DecimalDigit :: `1` or of NonZeroDigit :: `1` or of HexDigit :: `1` or of OctalDigit :: `1` or of BinaryDigit :: `1` is 1.
+
+
+ The MV of DecimalDigit :: `2` or of NonZeroDigit :: `2` or of HexDigit :: `2` or of OctalDigit :: `2` is 2.
+
+
+ The MV of DecimalDigit :: `3` or of NonZeroDigit :: `3` or of HexDigit :: `3` or of OctalDigit :: `3` is 3.
+
+
+ The MV of DecimalDigit :: `4` or of NonZeroDigit :: `4` or of HexDigit :: `4` or of OctalDigit :: `4` is 4.
+
+
+ The MV of DecimalDigit :: `5` or of NonZeroDigit :: `5` or of HexDigit :: `5` or of OctalDigit :: `5` is 5.
+
+
+ The MV of DecimalDigit :: `6` or of NonZeroDigit :: `6` or of HexDigit :: `6` or of OctalDigit :: `6` is 6.
+
+
+ The MV of DecimalDigit :: `7` or of NonZeroDigit :: `7` or of HexDigit :: `7` or of OctalDigit :: `7` is 7.
+
+
+ The MV of DecimalDigit :: `8` or of NonZeroDigit :: `8` or of HexDigit :: `8` is 8.
+
+
+ The MV of DecimalDigit :: `9` or of NonZeroDigit :: `9` or of HexDigit :: `9` is 9.
+
+
+ The MV of HexDigit :: `a` or of HexDigit :: `A` is 10.
+
+
+ The MV of HexDigit :: `b` or of HexDigit :: `B` is 11.
+
+
+ The MV of HexDigit :: `c` or of HexDigit :: `C` is 12.
+
+
+ The MV of HexDigit :: `d` or of HexDigit :: `D` is 13.
+
+
+ The MV of HexDigit :: `e` or of HexDigit :: `E` is 14.
+
+
+ The MV of HexDigit :: `f` or of HexDigit :: `F` is 15.
+
+
+ The MV of BinaryIntegerLiteral :: `0b` BinaryDigits is the MV of |BinaryDigits|.
+
+
+ The MV of BinaryIntegerLiteral :: `0B` BinaryDigits is the MV of |BinaryDigits|.
+
+
+ The MV of BinaryDigits :: BinaryDigit is the MV of |BinaryDigit|.
+
+
+ The MV of BinaryDigits :: BinaryDigits BinaryDigit is (the MV of |BinaryDigits| × 2) plus the MV of |BinaryDigit|.
+
+
+ The MV of OctalIntegerLiteral :: `0o` OctalDigits is the MV of |OctalDigits|.
+
+
+ The MV of OctalIntegerLiteral :: `0O` OctalDigits is the MV of |OctalDigits|.
+
+
+ The MV of OctalDigits :: OctalDigit is the MV of |OctalDigit|.
+
+
+ The MV of OctalDigits :: OctalDigits OctalDigit is (the MV of |OctalDigits| × 8) plus the MV of |OctalDigit|.
+
+
+ The MV of HexIntegerLiteral :: `0x` HexDigits is the MV of |HexDigits|.
+
+
+ The MV of HexIntegerLiteral :: `0X` HexDigits is the MV of |HexDigits|.
+
+
+ The MV of HexDigits :: HexDigit is the MV of |HexDigit|.
+
+
+ The MV of HexDigits :: HexDigits HexDigit is (the MV of |HexDigits| × 16) plus the MV of |HexDigit|.
+
+
+
Once the exact MV for a numeric literal has been determined, it is then rounded to a value of the Number type. If the MV is 0, then the rounded value is *+0*; otherwise, the rounded value must be the Number value for the MV (as specified in ), unless the literal is a |DecimalLiteral| and the literal has more than 20 significant digits, in which case the Number value may be either the Number value for the MV of a literal produced by replacing each significant digit after the 20th with a `0` digit or the Number value for the MV of a literal produced by replacing each significant digit after the 20th with a `0` digit and then incrementing the literal at the 20th significant digit position. A digit is significant if it is not part of an |ExponentPart| and
+
+
+ it is not `0`; or
+
+
+ there is a nonzero digit to its left and there is a nonzero digit, not in the |ExponentPart|, to its right.
+
+
+
+
+
+
+
+
String Literals
+
+
A string literal is zero or more Unicode code points enclosed in single or double quotes. Unicode code points may also be represented by an escape sequence. All code points may appear literally in a string literal except for the closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), U+2028 (LINE SEPARATOR), U+2029 (PARAGRAPH SEPARATOR), and U+000A (LINE FEED). Any code points may appear in the form of an escape sequence. String literals evaluate to ECMAScript String values. When generating these String values Unicode code points are UTF-16 encoded as defined in . Code points belonging to the Basic Multilingual Plane are encoded as a single code unit element of the string. All other code points are encoded as two code unit elements of the string.
+
+
Syntax
+
+ StringLiteral ::
+ `"` DoubleStringCharacters? `"`
+ `'` SingleStringCharacters? `'`
+
+ DoubleStringCharacters ::
+ DoubleStringCharacter DoubleStringCharacters?
+
+ SingleStringCharacters ::
+ SingleStringCharacter SingleStringCharacters?
+
+ DoubleStringCharacter ::
+ SourceCharacter but not one of `"` or `\` or LineTerminator
+ `\` EscapeSequence
+ LineContinuation
+
+ SingleStringCharacter ::
+ SourceCharacter but not one of `'` or `\` or LineTerminator
+ `\` EscapeSequence
+ LineContinuation
+
+ LineContinuation ::
+ `\` LineTerminatorSequence
+
+ EscapeSequence ::
+ CharacterEscapeSequence
+ `0` [lookahead <! DecimalDigit]
+ HexEscapeSequence
+ UnicodeEscapeSequence
+
+
A conforming implementation, when processing strict mode code (see ), must not extend the syntax of |EscapeSequence| to include |LegacyOctalEscapeSequence| as described in .
The definition of the nonterminal |HexDigit| is given in . |SourceCharacter| is defined in .
+
+
A line terminator code point cannot appear in a string literal, except as part of a |LineContinuation| to produce the empty code points sequence. The proper way to cause a line terminator code point to be part of the String value of a string literal is to use an escape sequence such as `\\n` or `\\u000A`.
+
+
+
+
+
Static Semantics: Early Errors
+ UnicodeEscapeSequence :: `u{` HexDigits `}`
+
+
+ It is a Syntax Error if the MV of |HexDigits| > 1114111.
+
+
+
+
+
+
+
Static Semantics: StringValue
+
+
+ StringLiteral ::
+ `"` DoubleStringCharacters? `"`
+ `'` SingleStringCharacters? `'`
+
+
+ 1. Return the String value whose elements are the SV of this |StringLiteral|.
+
+
+
+
+
+
Static Semantics: SV
+
A string literal stands for a value of the String type. The String value (SV) of the literal is described in terms of code unit values contributed by the various parts of the string literal. As part of this process, some Unicode code points within the string literal are interpreted as having a mathematical value (MV), as described below or in .
+
+
+ The SV of StringLiteral :: `"` `"` is the empty code unit sequence.
+
+
+ The SV of StringLiteral :: `'` `'` is the empty code unit sequence.
+
+
+ The SV of StringLiteral :: `"` DoubleStringCharacters `"` is the SV of |DoubleStringCharacters|.
+
+
+ The SV of StringLiteral :: `'` SingleStringCharacters `'` is the SV of |SingleStringCharacters|.
+
+
+ The SV of DoubleStringCharacters :: DoubleStringCharacter is a sequence of one or two code units that is the SV of |DoubleStringCharacter|.
+
+
+ The SV of DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharacters is a sequence of one or two code units that is the SV of |DoubleStringCharacter| followed by all the code units in the SV of |DoubleStringCharacters| in order.
+
+
+ The SV of SingleStringCharacters :: SingleStringCharacter is a sequence of one or two code units that is the SV of |SingleStringCharacter|.
+
+
+ The SV of SingleStringCharacters :: SingleStringCharacter SingleStringCharacters is a sequence of one or two code units that is the SV of |SingleStringCharacter| followed by all the code units in the SV of |SingleStringCharacters| in order.
+
+
+ The SV of DoubleStringCharacter :: SourceCharacter but not one of `"` or `\` or LineTerminator is the UTF16Encoding () of the code point value of |SourceCharacter|.
+
+
+ The SV of DoubleStringCharacter :: `\` EscapeSequence is the SV of the |EscapeSequence|.
+
+
+ The SV of DoubleStringCharacter :: LineContinuation is the empty code unit sequence.
+
+
+ The SV of SingleStringCharacter :: SourceCharacter but not one of `'` or `\` or LineTerminator is the UTF16Encoding () of the code point value of |SourceCharacter|.
+
+
+ The SV of SingleStringCharacter :: `\` EscapeSequence is the SV of the |EscapeSequence|.
+
+
+ The SV of SingleStringCharacter :: LineContinuation is the empty code unit sequence.
+
+
+ The SV of EscapeSequence :: CharacterEscapeSequence is the SV of the |CharacterEscapeSequence|.
+
+
+ The SV of EscapeSequence :: `0` is the code unit value 0.
+
+
+ The SV of EscapeSequence :: HexEscapeSequence is the SV of the |HexEscapeSequence|.
+
+
+ The SV of EscapeSequence :: UnicodeEscapeSequence is the SV of the |UnicodeEscapeSequence|.
+
+
+ The SV of CharacterEscapeSequence :: SingleEscapeCharacter is the code unit whose value is determined by the |SingleEscapeCharacter| according to .
+
+
+
+
+
+
+
+ Escape Sequence
+
+
+ Code Unit Value
+
+
+ Unicode Character Name
+
+
+ Symbol
+
+
+
+
+ `\\b`
+
+
+ `0x0008`
+
+
+ BACKSPACE
+
+
+ <BS>
+
+
+
+
+ `\\t`
+
+
+ `0x0009`
+
+
+ CHARACTER TABULATION
+
+
+ <HT>
+
+
+
+
+ `\\n`
+
+
+ `0x000A`
+
+
+ LINE FEED (LF)
+
+
+ <LF>
+
+
+
+
+ `\\v`
+
+
+ `0x000B`
+
+
+ LINE TABULATION
+
+
+ <VT>
+
+
+
+
+ `\\f`
+
+
+ `0x000C`
+
+
+ FORM FEED (FF)
+
+
+ <FF>
+
+
+
+
+ `\\r`
+
+
+ `0x000D`
+
+
+ CARRIAGE RETURN (CR)
+
+
+ <CR>
+
+
+
+
+ `\\"`
+
+
+ `0x0022`
+
+
+ QUOTATION MARK
+
+
+ `"`
+
+
+
+
+ `\\'`
+
+
+ `0x0027`
+
+
+ APOSTROPHE
+
+
+ `'`
+
+
+
+
+ `\\\\`
+
+
+ `0x005C`
+
+
+ REVERSE SOLIDUS
+
+
+ `\\`
+
+
+
+
+
+
+
+ The SV of CharacterEscapeSequence :: NonEscapeCharacter is the SV of the |NonEscapeCharacter|.
+
+
+ The SV of NonEscapeCharacter :: SourceCharacter but not one of EscapeCharacter or LineTerminator is the UTF16Encoding () of the code point value of |SourceCharacter|.
+
+
+ The SV of HexEscapeSequence :: `x` HexDigit HexDigit is the code unit value that is (16 times the MV of the first |HexDigit|) plus the MV of the second |HexDigit|.
+
+
+ The SV of UnicodeEscapeSequence :: `u` Hex4Digits is the SV of |Hex4Digits|.
+
+
+ The SV of Hex4Digits :: HexDigit HexDigit HexDigit HexDigit is the code unit value that is (4096 times the MV of the first |HexDigit|) plus (256 times the MV of the second |HexDigit|) plus (16 times the MV of the third |HexDigit|) plus the MV of the fourth |HexDigit|.
+
+
+ The SV of UnicodeEscapeSequence :: `u{` HexDigits `}` is the UTF16Encoding () of the MV of |HexDigits|.
+
+
+
+
+
+
+
+
Regular Expression Literals
+
+
A regular expression literal is an input element that is converted to a RegExp object (see ) each time the literal is evaluated. Two regular expression literals in a program evaluate to regular expression objects that never compare as `===` to each other even if the two literals' contents are identical. A RegExp object may also be created at runtime by `new RegExp` or calling the `RegExp` constructor as a function (see ).
+
+
The productions below describe the syntax for a regular expression literal and are used by the input element scanner to find the end of the regular expression literal. The source text comprising the |RegularExpressionBody| and the |RegularExpressionFlags| are subsequently parsed again using the more stringent ECMAScript Regular Expression grammar ().
+
An implementation may extend the ECMAScript Regular Expression grammar defined in , but it must not extend the |RegularExpressionBody| and |RegularExpressionFlags| productions defined below or the productions used by these productions.
+
Syntax
+
+ RegularExpressionLiteral ::
+ `/` RegularExpressionBody `/` RegularExpressionFlags
+
+ RegularExpressionBody ::
+ RegularExpressionFirstChar RegularExpressionChars
+
+ RegularExpressionChars ::
+ [empty]
+ RegularExpressionChars RegularExpressionChar
+
+ RegularExpressionFirstChar ::
+ RegularExpressionNonTerminator but not one of `*` or `\` or `/` or `[`
+ RegularExpressionBackslashSequence
+ RegularExpressionClass
+
+ RegularExpressionChar ::
+ RegularExpressionNonTerminator but not one of `\` or `/` or `[`
+ RegularExpressionBackslashSequence
+ RegularExpressionClass
+
+ RegularExpressionBackslashSequence ::
+ `\` RegularExpressionNonTerminator
+
+ RegularExpressionNonTerminator ::
+ SourceCharacter but not LineTerminator
+
+ RegularExpressionClass ::
+ `[` RegularExpressionClassChars `]`
+
+ RegularExpressionClassChars ::
+ [empty]
+ RegularExpressionClassChars RegularExpressionClassChar
+
+ RegularExpressionClassChar ::
+ RegularExpressionNonTerminator but not one of `]` or `\`
+ RegularExpressionBackslashSequence
+
+ RegularExpressionFlags ::
+ [empty]
+ RegularExpressionFlags IdentifierPart
+
+
+
Regular expression literals may not be empty; instead of representing an empty regular expression literal, the code unit sequence `//` starts a single-line comment. To specify an empty regular expression, use: `/(?:)/`.
+ It is a Syntax Error if |IdentifierPart| contains a Unicode escape sequence.
+
+
+
+
+
+
+
Static Semantics: BodyText
+ RegularExpressionLiteral :: `/` RegularExpressionBody `/` RegularExpressionFlags
+
+ 1. Return the source text that was recognized as |RegularExpressionBody|.
+
+
+
+
+
+
Static Semantics: FlagText
+ RegularExpressionLiteral :: `/` RegularExpressionBody `/` RegularExpressionFlags
+
+ 1. Return the source text that was recognized as |RegularExpressionFlags|.
+
+
+
+
+
+
+
A conforming implementation must not use the extended definition of |EscapeSequence| described in when parsing a |TemplateCharacter|.
+
+
|TemplateSubstitutionTail| is used by the |InputElementTemplateTail| alternative lexical goal.
+
+
+
+
+
Static Semantics: TV and TRV
+
A template literal component is interpreted as a sequence of Unicode code points. The Template Value (TV) of a literal component is described in terms of code unit values (SV, ) contributed by the various parts of the template literal component. As part of this process, some Unicode code points within the template component are interpreted as having a mathematical value (MV, ). In determining a TV, escape sequences are replaced by the UTF-16 code unit(s) of the Unicode code point represented by the escape sequence. The Template Raw Value (TRV) is similar to a Template Value with the difference that in TRVs escape sequences are interpreted literally.
+
+
+ The TV and TRV of NoSubstitutionTemplate :: ``` ``` is the empty code unit sequence.
+
+
+ The TV and TRV of TemplateHead :: ``` `${` is the empty code unit sequence.
+
+
+ The TV and TRV of TemplateMiddle :: `}` `${` is the empty code unit sequence.
+
+
+ The TV and TRV of TemplateTail :: `}` ``` is the empty code unit sequence.
+
+
+ The TV of NoSubstitutionTemplate :: ``` TemplateCharacters ``` is the TV of |TemplateCharacters|.
+
+
+ The TV of TemplateHead :: ``` TemplateCharacters `${` is the TV of |TemplateCharacters|.
+
+
+ The TV of TemplateMiddle :: `}` TemplateCharacters `${` is the TV of |TemplateCharacters|.
+
+
+ The TV of TemplateTail :: `}` TemplateCharacters ``` is the TV of |TemplateCharacters|.
+
+
+ The TV of TemplateCharacters :: TemplateCharacter is the TV of |TemplateCharacter|.
+
+
+ The TV of TemplateCharacters :: TemplateCharacter TemplateCharacters is a sequence consisting of the code units in the TV of |TemplateCharacter| followed by all the code units in the TV of |TemplateCharacters| in order.
+
+
+ The TV of TemplateCharacter :: SourceCharacter but not one of ``` or `\` or `$` or LineTerminator is the UTF16Encoding () of the code point value of |SourceCharacter|.
+
+
+ The TV of TemplateCharacter :: `$` is the code unit value 0x0024.
+
+
+ The TV of TemplateCharacter :: `\` EscapeSequence is the SV of |EscapeSequence|.
+
+
+ The TV of TemplateCharacter :: LineContinuation is the TV of |LineContinuation|.
+
+
+ The TV of TemplateCharacter :: LineTerminatorSequence is the TRV of |LineTerminatorSequence|.
+
+
+ The TV of LineContinuation :: `\` LineTerminatorSequence is the empty code unit sequence.
+
+
+ The TRV of NoSubstitutionTemplate :: ``` TemplateCharacters ``` is the TRV of |TemplateCharacters|.
+
+
+ The TRV of TemplateHead :: ``` TemplateCharacters `${` is the TRV of |TemplateCharacters|.
+
+
+ The TRV of TemplateMiddle :: `}` TemplateCharacters `${` is the TRV of |TemplateCharacters|.
+
+
+ The TRV of TemplateTail :: `}` TemplateCharacters ``` is the TRV of |TemplateCharacters|.
+
+
+ The TRV of TemplateCharacters :: TemplateCharacter is the TRV of |TemplateCharacter|.
+
+
+ The TRV of TemplateCharacters :: TemplateCharacter TemplateCharacters is a sequence consisting of the code units in the TRV of |TemplateCharacter| followed by all the code units in the TRV of |TemplateCharacters|, in order.
+
+
+ The TRV of TemplateCharacter :: SourceCharacter but not one of ``` or `\` or `$` or LineTerminator is the UTF16Encoding () of the code point value of |SourceCharacter|.
+
+
+ The TRV of TemplateCharacter :: `$` is the code unit value 0x0024.
+
+
+ The TRV of TemplateCharacter :: `\` EscapeSequence is the sequence consisting of the code unit value 0x005C followed by the code units of TRV of |EscapeSequence|.
+
+
+ The TRV of TemplateCharacter :: LineContinuation is the TRV of |LineContinuation|.
+
+
+ The TRV of TemplateCharacter :: LineTerminatorSequence is the TRV of |LineTerminatorSequence|.
+
+
+ The TRV of EscapeSequence :: CharacterEscapeSequence is the TRV of the |CharacterEscapeSequence|.
+
+
+ The TRV of EscapeSequence :: `0` is the code unit value 0x0030.
+
+
+ The TRV of EscapeSequence :: HexEscapeSequence is the TRV of the |HexEscapeSequence|.
+
+
+ The TRV of EscapeSequence :: UnicodeEscapeSequence is the TRV of the |UnicodeEscapeSequence|.
+
+
+ The TRV of CharacterEscapeSequence :: SingleEscapeCharacter is the TRV of the |SingleEscapeCharacter|.
+
+
+ The TRV of CharacterEscapeSequence :: NonEscapeCharacter is the SV of the |NonEscapeCharacter|.
+
+
+ The TRV of SingleEscapeCharacter :: one of `'` `"` `\` `b` `f` `n` `r` `t` `v` is the SV of the |SourceCharacter| that is that single code point.
+
+
+ The TRV of HexEscapeSequence :: `x` HexDigit HexDigit is the sequence consisting of code unit value 0x0078 followed by TRV of the first |HexDigit| followed by the TRV of the second |HexDigit|.
+
+
+ The TRV of UnicodeEscapeSequence :: `u` Hex4Digits is the sequence consisting of code unit value 0x0075 followed by TRV of |Hex4Digits|.
+
+
+ The TRV of UnicodeEscapeSequence :: `u{` HexDigits `}` is the sequence consisting of code unit value 0x0075 followed by code unit value 0x007B followed by TRV of |HexDigits| followed by code unit value 0x007D.
+
+
+ The TRV of Hex4Digits :: HexDigit HexDigit HexDigit HexDigit is the sequence consisting of the TRV of the first |HexDigit| followed by the TRV of the second |HexDigit| followed by the TRV of the third |HexDigit| followed by the TRV of the fourth |HexDigit|.
+
+
+ The TRV of HexDigits :: HexDigit is the TRV of |HexDigit|.
+
+
+ The TRV of HexDigits :: HexDigits HexDigit is the sequence consisting of TRV of |HexDigits| followed by TRV of |HexDigit|.
+
+
+ The TRV of a |HexDigit| is the SV of the |SourceCharacter| that is that |HexDigit|.
+
+
+ The TRV of LineContinuation :: `\` LineTerminatorSequence is the sequence consisting of the code unit value 0x005C followed by the code units of TRV of |LineTerminatorSequence|.
+
+
+ The TRV of LineTerminatorSequence :: <LF> is the code unit value 0x000A.
+
+
+ The TRV of LineTerminatorSequence :: <CR> is the code unit value 0x000A.
+
+
+ The TRV of LineTerminatorSequence :: <LS> is the code unit value 0x2028.
+
+
+ The TRV of LineTerminatorSequence :: <PS> is the code unit value 0x2029.
+
+
+ The TRV of LineTerminatorSequence :: <CR><LF> is the sequence consisting of the code unit value 0x000A.
+
+
+
+
TV excludes the code units of |LineContinuation| while TRV includes them. <CR><LF> and <CR> |LineTerminatorSequence|s are normalized to <LF> for both TV and TRV. An explicit |EscapeSequence| is needed to include a <CR> or <CR><LF> sequence.
+
+
+
+
+
+
+
+
Automatic Semicolon Insertion
+
Certain ECMAScript statements (empty statement, `let`, `const`, `import`, and `export` declarations, variable statement, expression statement, `debugger` statement, `continue` statement, `break` statement, `return` statement, and `throw` statement) must be terminated with semicolons. Such semicolons may always appear explicitly in the source text. For convenience, however, such semicolons may be omitted from the source text in certain situations. These situations are described by saying that semicolons are automatically inserted into the source code token stream in those situations.
+
+
+
+
Rules of Automatic Semicolon Insertion
+
In the following rules, “token” means the actual recognized lexical token determined using the current lexical goal symbol as described in clause .
+
There are three basic rules of semicolon insertion:
+
+
+ When, as a |Script| or |Module| is parsed from left to right, a token (called the offending token) is encountered that is not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending token if one or more of the following conditions is true:
+
+
+ The offending token is separated from the previous token by at least one |LineTerminator|.
+
+
+ The offending token is `}`.
+
+
+ The previous token is `)` and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement ().
+
+
+
+
+ When, as the |Script| or |Module| is parsed from left to right, the end of the input stream of tokens is encountered and the parser is unable to parse the input token stream as a single complete ECMAScript |Script| or |Module|, then a semicolon is automatically inserted at the end of the input stream.
+
+
+ When, as the |Script| or |Module| is parsed from left to right, a token is encountered that is allowed by some production of the grammar, but the production is a restricted production and the token would be the first token for a terminal or nonterminal immediately following the annotation “[no |LineTerminator| here]” within the restricted production (and therefore such a token is called a restricted token), and the restricted token is separated from the previous token by at least one |LineTerminator|, then a semicolon is automatically inserted before the restricted token.
+
+
+
However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a `for` statement (see ).
+
+
The following are the only restricted productions in the grammar:
The practical effect of these restricted productions is as follows:
+
+
+ When a `++` or `--` token is encountered where the parser would treat it as a postfix operator, and at least one |LineTerminator| occurred between the preceding token and the `++` or `--` token, then a semicolon is automatically inserted before the `++` or `--` token.
+
+
+ When a `continue`, `break`, `return`, `throw`, or `yield` token is encountered and a |LineTerminator| is encountered before the next token, a semicolon is automatically inserted after the `continue`, `break`, `return`, `throw`, or `yield` token.
+
+
+
The resulting practical advice to ECMAScript programmers is:
+
+
+ A postfix `++` or `--` operator should appear on the same line as its operand.
+
+
+ An |Expression| in a `return` or `throw` statement or an |AssignmentExpression| in a `yield` expression should start on the same line as the `return`, `throw`, or `yield` token.
+
+
+ A |LabelIdentifier| in a `break` or `continue` statement should be on the same line as the `break` or `continue` token.
+
+
+
+
+
+
+
+
Examples of Automatic Semicolon Insertion
+
The source
+
{ 1 2 } 3
+
is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source
+
+{ 1
+2 } 3
+
+
is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:
+
+{ 1
+;2 ;} 3;
+
+
which is a valid ECMAScript sentence.
+
The source
+
+for (a; b
+)
+
+
is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion because the semicolon is needed for the header of a `for` statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of a `for` statement.
+
The source
+
+return
+a + b
+
+
is transformed by automatic semicolon insertion into the following:
+
+return;
+a + b;
+
+
+
The expression `a + b` is not treated as a value to be returned by the `return` statement, because a |LineTerminator| separates it from the token `return`.
+
+
The source
+
+a = b
+++c
+
+
is transformed by automatic semicolon insertion into the following:
+
+a = b;
+++c;
+
+
+
The token `++` is not treated as a postfix operator applying to the variable `b`, because a |LineTerminator| occurs between `b` and `++`.
+
+
The source
+
+if (a > b)
+else c = d
+
+
is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before the `else` token, even though no production of the grammar applies at that point, because an automatically inserted semicolon would then be parsed as an empty statement.
+
The source
+
+a = b + c
+(d + e).print()
+
+
is not transformed by automatic semicolon insertion, because the parenthesized expression that begins the second line can be interpreted as an argument list for a function call:
+
a = b + c(d + e).print()
+
In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.
+ It is a Syntax Error if the code matched by this production is contained in strict mode code and the StringValue of |Identifier| is `"arguments"` or `"eval"`.
+
+ It is a Syntax Error if this production has a [Yield] parameter and StringValue of |Identifier| is `"yield"`.
+
+
+ Identifier : IdentifierName but not ReservedWord
+
+
+ It is a Syntax Error if this phrase is contained in strict mode code and the StringValue of |IdentifierName| is: `"implements"`, `"interface"`, `"let"`, `"package"`, `"private"`, `"protected"`, `"public"`, `"static"`, or `"yield"`.
+
+
+ It is a Syntax Error if StringValue of |IdentifierName| is the same String value as the StringValue of any |ReservedWord| except for `yield`.
+
+
+
+
StringValue of |IdentifierName| normalizes any Unicode escape sequences in |IdentifierName| hence such escapes cannot be used to write an |Identifier| whose code point sequence is the same as a |ReservedWord|.
+
+
+
+
+
+
Static Semantics: BoundNames
+
+ BindingIdentifier : Identifier
+
+ 1. Return a new List containing the StringValue of |Identifier|.
+
+ BindingIdentifier : `yield`
+
+ 1. Return a new List containing `"yield"`.
+
+
+
+
+
+
Static Semantics: IsValidSimpleAssignmentTarget
+
+ IdentifierReference : Identifier
+
+ 1. If this |IdentifierReference| is contained in strict mode code and StringValue of |Identifier| is `"eval"` or `"arguments"`, return *false*.
+ 1. Return *true*.
+
+ IdentifierReference : `yield`
+
+ 1. Return *true*.
+
+
+
+
+
+
*undefined* is passed for _environment_ to indicate that a PutValue operation should be used to assign the initialization value. This is the case for `var` statements and formal parameter lists of some non-strict functions (See ). In those cases a lexical binding is hoisted and preinitialized prior to evaluation of its initializer.
+
+ 1. Assert: Type(_name_) is String.
+ 1. If _environment_ is not *undefined*, then
+ 1. Let _env_ be the EnvironmentRecord component of _environment_.
+ 1. Perform _env_.InitializeBinding(_name_, _value_).
+ 1. Return NormalCompletion(*undefined*).
+ 1. Else,
+ 1. Let _lhs_ be ResolveBinding(_name_).
+ 1. Return PutValue(_lhs_, _value_).
+
+
+
+
+
+
+
The result of evaluating an |IdentifierReference| is always a value of type Reference.
+
+
+
In non-strict code, the keyword `yield` may be used as an identifier. Evaluating the |IdentifierReference| production resolves the binding of `yield` as if it was an |Identifier|. Early Error restriction ensures that such an evaluation only can occur for non-strict code. See for the handling of `yield` in binding creation contexts.
When processing the production
+
+ PrimaryExpression[Yield] : CoverParenthesizedExpressionAndArrowParameterList[?Yield]
+
+ the interpretation of |CoverParenthesizedExpressionAndArrowParameterList| is refined using the following grammar:
+ CoverParenthesizedExpressionAndArrowParameterList[Yield] : `(` Expression[In, ?Yield] `)`
+
+ 1. Return the result of parsing the lexical token stream matched by |CoverParenthesizedExpressionAndArrowParameterList[Yield]| using either |ParenthesizedExpression| or |ParenthesizedExpression[Yield]| as the goal symbol depending upon whether the [Yield] grammar parameter was present when |CoverParenthesizedExpressionAndArrowParameterList| was matched.
+
+
+
+
+
+
Static Semantics: HasName
+
+ PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
+
+ 1. Let _expr_ be CoveredParenthesizedExpression of |CoverParenthesizedExpressionAndArrowParameterList|.
+ 1. If IsFunctionDefinition of _expr_ is *false*, return *false*.
+ 1. Return HasName of _expr_.
+
+
+
+
+
+
+ Literal : NullLiteral
+
+ 1. Return *null*.
+
+ Literal : BooleanLiteral
+
+ 1. Return *false* if |BooleanLiteral| is the token `false`.
+ 1. Return *true* if |BooleanLiteral| is the token `true`.
+
+ Literal : NumericLiteral
+
+ 1. Return the number whose value is MV of |NumericLiteral| as defined in .
+
+ Literal : StringLiteral
+
+ 1. Return the StringValue of |StringLiteral| as defined in .
+
+
+
+
+
+
+
Array Initializer
+
+
An |ArrayLiteral| is an expression describing the initialization of an Array object, using a list, of zero or more expressions each of which represents an array element, enclosed in square brackets. The elements need not be literals; they are evaluated each time the array initializer is evaluated.
+
+
Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an |AssignmentExpression| (i.e., a comma at the beginning or after another comma), the missing array element contributes to the length of the Array and increases the index of subsequent elements. Elided array elements are not defined. If an element is elided at the end of an array, that element does not contribute to the length of the Array.
+ Elision : `,`
+
+ 1. Return the numeric value 1.
+
+ Elision : Elision `,`
+
+ 1. Let _preceding_ be the ElisionWidth of |Elision|.
+ 1. Return _preceding_+1.
+
+
+
+
+
+
Runtime Semantics: ArrayAccumulation
+
With parameters _array_ and _nextIndex_.
+ ElementList : Elision? AssignmentExpression
+
+ 1. Let _padding_ be the ElisionWidth of |Elision|; if |Elision| is not present, use the numeric value zero.
+ 1. Let _initResult_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _initValue_ be ? GetValue(_initResult_).
+ 1. Let _created_ be CreateDataProperty(_array_, ToString(ToUint32(_nextIndex_+_padding_)), _initValue_).
+ 1. Assert: _created_ is *true*.
+ 1. Return _nextIndex_+_padding_+1.
+
+ ElementList : Elision? SpreadElement
+
+ 1. Let _padding_ be the ElisionWidth of |Elision|; if |Elision| is not present, use the numeric value zero.
+ 1. Return the result of performing ArrayAccumulation for |SpreadElement| with arguments _array_ and _nextIndex_+_padding_.
+
+ ElementList : ElementList `,` Elision? AssignmentExpression
+
+ 1. Let _postIndex_ be the result of performing ArrayAccumulation for |ElementList| with arguments _array_ and _nextIndex_.
+ 1. ReturnIfAbrupt(_postIndex_).
+ 1. Let _padding_ be the ElisionWidth of |Elision|; if |Elision| is not present, use the numeric value zero.
+ 1. Let _initResult_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _initValue_ be ? GetValue(_initResult_).
+ 1. Let _created_ be CreateDataProperty(_array_, ToString(ToUint32(_postIndex_+_padding_)), _initValue_).
+ 1. Assert: _created_ is *true*.
+ 1. Return _postIndex_+_padding_+1.
+
+ ElementList : ElementList `,` Elision? SpreadElement
+
+ 1. Let _postIndex_ be the result of performing ArrayAccumulation for |ElementList| with arguments _array_ and _nextIndex_.
+ 1. ReturnIfAbrupt(_postIndex_).
+ 1. Let _padding_ be the ElisionWidth of |Elision|; if |Elision| is not present, use the numeric value zero.
+ 1. Return the result of performing ArrayAccumulation for |SpreadElement| with arguments _array_ and _postIndex_+_padding_.
+
+ SpreadElement : `...` AssignmentExpression
+
+ 1. Let _spreadRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _spreadObj_ be GetValue(_spreadRef_).
+ 1. Let _iterator_ be ? GetIterator(_spreadObj_).
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iterator_).
+ 1. If _next_ is *false*, return _nextIndex_.
+ 1. Let _nextValue_ be ? IteratorValue(_next_).
+ 1. Let _status_ be CreateDataProperty(_array_, ToString(ToUint32(_nextIndex_)), _nextValue_).
+ 1. Assert: _status_ is *true* .
+ 1. Let _nextIndex_ be _nextIndex_ + 1.
+
+
+
CreateDataProperty is used to ensure that own properties are defined for the array even if the standard built-in Array prototype object has been modified in a manner that would preclude the creation of new own properties using [[Set]].
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ ArrayLiteral : `[` Elision? `]`
+
+ 1. Let _array_ be ArrayCreate(0).
+ 1. Let _pad_ be the ElisionWidth of |Elision|; if |Elision| is not present, use the numeric value zero.
+ 1. Perform Set(_array_, `"length"`, ToUint32(_pad_), *false*).
+ 1. NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
+ 1. Return _array_.
+
+ ArrayLiteral : `[` ElementList `]`
+
+ 1. Let _array_ be ArrayCreate(0).
+ 1. Let _len_ be the result of performing ArrayAccumulation for |ElementList| with arguments _array_ and 0.
+ 1. ReturnIfAbrupt(_len_).
+ 1. Perform Set(_array_, `"length"`, ToUint32(_len_), *false*).
+ 1. NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
+ 1. Return _array_.
+
+ ArrayLiteral : `[` ElementList `,` Elision? `]`
+
+ 1. Let _array_ be ArrayCreate(0).
+ 1. Let _len_ be the result of performing ArrayAccumulation for |ElementList| with arguments _array_ and 0.
+ 1. ReturnIfAbrupt(_len_).
+ 1. Let _padding_ be the ElisionWidth of |Elision|; if |Elision| is not present, use the numeric value zero.
+ 1. Perform Set(_array_, `"length"`, ToUint32(_padding_+_len_), *false*).
+ 1. NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
+ 1. Return _array_.
+
+
+
+
+
+
+
Object Initializer
+
+
An object initializer is an expression describing the initialization of an Object, written in a form resembling a literal. It is a list of zero or more pairs of property keys and associated values, enclosed in curly brackets. The values need not be literals; they are evaluated each time the object initializer is evaluated.
In certain contexts, |ObjectLiteral| is used as a cover grammar for a more restricted secondary grammar. The |CoverInitializedName| production is necessary to fully cover these secondary grammars. However, use of this production results in an early Syntax Error in normal contexts where an actual |ObjectLiteral| is expected.
+
+
+
+
+
Static Semantics: Early Errors
+ PropertyDefinition : MethodDefinition
+
+
+ It is a Syntax Error if HasDirectSuper of |MethodDefinition| is *true*.
+
+
+
In addition to describing an actual object initializer the |ObjectLiteral| productions are also used as a cover grammar for |ObjectAssignmentPattern| (). and may be recognized as part of a |CoverParenthesizedExpressionAndArrowParameterList|. When |ObjectLiteral| appears in a context where |ObjectAssignmentPattern| is required the following Early Error rules are not applied. In addition, they are not applied when initially parsing a |CoverParenthesizedExpressionAndArrowParameterList|.
+ PropertyDefinition : CoverInitializedName
+
+
+ Always throw a Syntax Error if code matches this production.
+
+
+
+
This production exists so that |ObjectLiteral| can serve as a cover grammar for |ObjectAssignmentPattern| (). It cannot occur in an actual object initializer.
+
+ PropertyDefinition : MethodDefinition
+
+ 1. If _symbol_ is |MethodDefinition|, return *true*.
+ 1. Return the result of ComputedPropertyContains for |MethodDefinition| with argument _symbol_.
+
+
+
Static semantic rules that depend upon substructure generally do not look into function definitions.
+
+ LiteralPropertyName : IdentifierName
+
+ 1. If _symbol_ is a |ReservedWord|, return *false*.
+ 1. If _symbol_ is an |Identifier| and StringValue of _symbol_ is the same value as the StringValue of |IdentifierName|, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
+
+ PropertyDefinition : IdentifierReference
+
+ 1. Return StringValue of |IdentifierReference|.
+
+ PropertyDefinition : PropertyName `:` AssignmentExpression
+
+ 1. Return PropName of |PropertyName|.
+
+ LiteralPropertyName : IdentifierName
+
+ 1. Return StringValue of |IdentifierName|.
+
+ LiteralPropertyName : StringLiteral
+
+ 1. Return a String value whose code units are the SV of the |StringLiteral|.
+
+ LiteralPropertyName : NumericLiteral
+
+ 1. Let _nbr_ be the result of forming the value of the |NumericLiteral|.
+ 1. Return ToString(_nbr_).
+
+ ComputedPropertyName : `[` AssignmentExpression `]`
+
+ 1. Return ~empty~.
+
+
+
+
+
+
Static Semantics: PropertyNameList
+ PropertyDefinitionList : PropertyDefinition
+
+ 1. If PropName of |PropertyDefinition| is ~empty~, return a new empty List.
+ 1. Return a new List containing PropName of |PropertyDefinition|.
+
+ PropertyDefinitionList : PropertyDefinitionList `,` PropertyDefinition
+
+ 1. Let _list_ be PropertyNameList of |PropertyDefinitionList|.
+ 1. If PropName of |PropertyDefinition| is ~empty~, return _list_.
+ 1. Append PropName of |PropertyDefinition| to the end of _list_.
+ 1. Return _list_.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ ObjectLiteral : `{` `}`
+
+ 1. Return ObjectCreate(%ObjectPrototype%).
+
+
+ ObjectLiteral :
+ `{` PropertyDefinitionList `}`
+ `{` PropertyDefinitionList `,` `}`
+
+
+ 1. Let _obj_ be ObjectCreate(%ObjectPrototype%).
+ 1. Let _status_ be the result of performing PropertyDefinitionEvaluation of |PropertyDefinitionList| with arguments _obj_ and *true*.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return _obj_.
+
+ LiteralPropertyName : IdentifierName
+
+ 1. Return StringValue of |IdentifierName|.
+
+ LiteralPropertyName : StringLiteral
+
+ 1. Return a String value whose code units are the SV of the |StringLiteral|.
+
+ LiteralPropertyName : NumericLiteral
+
+ 1. Let _nbr_ be the result of forming the value of the |NumericLiteral|.
+ 1. Return ToString(_nbr_).
+
+ ComputedPropertyName : `[` AssignmentExpression `]`
+
+ 1. Let _exprValue_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _propName_ be ? GetValue(_exprValue_).
+ 1. Return ToPropertyKey(_propName_).
+
+
+
+
+
+
Runtime Semantics: PropertyDefinitionEvaluation
+
With parameters _object_ and _enumerable_.
+
+ PropertyDefinitionList : PropertyDefinitionList `,` PropertyDefinition
+
+ 1. Let _status_ be the result of performing PropertyDefinitionEvaluation of |PropertyDefinitionList| with arguments _object_ and _enumerable_.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing PropertyDefinitionEvaluation of |PropertyDefinition| with arguments _object_ and _enumerable_.
+
+ PropertyDefinition : IdentifierReference
+
+ 1. Let _propName_ be StringValue of |IdentifierReference|.
+ 1. Let _exprValue_ be the result of evaluating |IdentifierReference|.
+ 1. Let _propValue_ be ? GetValue(_exprValue_).
+ 1. Assert: _enumerable_ is *true*.
+ 1. Return CreateDataPropertyOrThrow(_object_, _propName_, _propValue_).
+
+ PropertyDefinition : PropertyName `:` AssignmentExpression
+
+ 1. Let _propKey_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_propKey_).
+ 1. Let _exprValueRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _propValue_ be ? GetValue(_exprValueRef_).
+ 1. If IsAnonymousFunctionDefinition(|AssignmentExpression|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_propValue_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_propValue_, _propKey_).
+ 1. Assert: _enumerable_ is *true*.
+ 1. Return CreateDataPropertyOrThrow(_object_, _propKey_, _propValue_).
+
+
+
An alternative semantics for this production is given in .
+
+
+
+
+
+
+
Function Defining Expressions
+
See for PrimaryExpression : FunctionExpression .
+
See for PrimaryExpression : GeneratorExpression .
+
See for PrimaryExpression : ClassExpression .
+
+
+
+
+
Regular Expression Literals
+
Syntax
+
See .
+
+
+
+
Static Semantics: Early Errors
+ PrimaryExpression : RegularExpressionLiteral
+
+
+ It is a Syntax Error if BodyText of |RegularExpressionLiteral| cannot be recognized using the goal symbol |Pattern| of the ECMAScript RegExp grammar specified in .
+
+
+ It is a Syntax Error if FlagText of |RegularExpressionLiteral| contains any code points other than `"g"`, `"i"`, `"m"`, `"u"`, or `"y"`, or if it contains the same code point more than once.
+
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ PrimaryExpression : RegularExpressionLiteral
+
+ 1. Let _pattern_ be the String value consisting of the UTF16Encoding of each code point of BodyText of |RegularExpressionLiteral|.
+ 1. Let _flags_ be the String value consisting of the UTF16Encoding of each code point of FlagText of |RegularExpressionLiteral|.
+ 1. Return RegExpCreate(_pattern_, _flags_).
+
+
+
+
+
+
+
+ TemplateLiteral : NoSubstitutionTemplate
+
+ 1. If _raw_ is *false*, then
+ 1. Let _string_ be the TV of |NoSubstitutionTemplate|.
+ 1. Else,
+ 1. Let _string_ be the TRV of |NoSubstitutionTemplate|.
+ 1. Return a List containing the single element, _string_.
+
+ TemplateLiteral : TemplateHead Expression TemplateSpans
+
+ 1. If _raw_ is *false*, then
+ 1. Let _head_ be the TV of |TemplateHead|.
+ 1. Else,
+ 1. Let _head_ be the TRV of |TemplateHead|.
+ 1. Let _tail_ be TemplateStrings of |TemplateSpans| with argument _raw_.
+ 1. Return a List containing _head_ followed by the elements, in order, of _tail_.
+
+ TemplateSpans : TemplateTail
+
+ 1. If _raw_ is *false*, then
+ 1. Let _tail_ be the TV of |TemplateTail|.
+ 1. Else,
+ 1. Let _tail_ be the TRV of |TemplateTail|.
+ 1. Return a List containing the single element, _tail_.
+
+ TemplateSpans : TemplateMiddleList TemplateTail
+
+ 1. Let _middle_ be TemplateStrings of |TemplateMiddleList| with argument _raw_.
+ 1. If _raw_ is *false*, then
+ 1. Let _tail_ be the TV of |TemplateTail|.
+ 1. Else,
+ 1. Let _tail_ be the TRV of |TemplateTail|.
+ 1. Return a List containing the elements, in order, of _middle_ followed by _tail_.
+
+ TemplateMiddleList : TemplateMiddle Expression
+
+ 1. If _raw_ is *false*, then
+ 1. Let _string_ be the TV of |TemplateMiddle|.
+ 1. Else,
+ 1. Let _string_ be the TRV of |TemplateMiddle|.
+ 1. Return a List containing the single element, _string_.
+
+ TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
+
+ 1. Let _front_ be TemplateStrings of |TemplateMiddleList| with argument _raw_.
+ 1. If _raw_ is *false*, then
+ 1. Let _last_ be the TV of |TemplateMiddle|.
+ 1. Else,
+ 1. Let _last_ be the TRV of |TemplateMiddle|.
+ 1. Append _last_ as the last element of the List _front_.
+ 1. Return _front_.
+
+
+
+
+
+
Runtime Semantics: ArgumentListEvaluation
+
+ TemplateLiteral : NoSubstitutionTemplate
+
+ 1. Let _templateLiteral_ be this |TemplateLiteral|.
+ 1. Let _siteObj_ be GetTemplateObject(_templateLiteral_).
+ 1. Return a List containing the one element which is _siteObj_.
+
+ TemplateLiteral : TemplateHead Expression TemplateSpans
+
+ 1. Let _templateLiteral_ be this |TemplateLiteral|.
+ 1. Let _siteObj_ be GetTemplateObject(_templateLiteral_).
+ 1. Let _firstSub_ be the result of evaluating |Expression|.
+ 1. ReturnIfAbrupt(_firstSub_).
+ 1. Let _restSub_ be SubstitutionEvaluation of |TemplateSpans|.
+ 1. ReturnIfAbrupt(_restSub_).
+ 1. Assert: _restSub_ is a List.
+ 1. Return a List whose first element is _siteObj_, whose second elements is _firstSub_, and whose subsequent elements are the elements of _restSub_, in order. _restSub_ may contain no elements.
+
+
+
+
+
+
The abstract operation GetTemplateObject is called with a grammar production, _templateLiteral_, as an argument. It performs the following steps:
+
+ 1. Let _rawStrings_ be TemplateStrings of _templateLiteral_ with argument *true*.
+ 1. Let _ctx_ be the running execution context.
+ 1. Let _realm_ be the _ctx_'s Realm.
+ 1. Let _templateRegistry_ be _realm_.[[templateMap]].
+ 1. For each element _e_ of _templateRegistry_, do
+ 1. If _e_.[[strings]] and _rawStrings_ contain the same values in the same order, then
+ 1. Return _e_.[[array]].
+ 1. Let _cookedStrings_ be TemplateStrings of _templateLiteral_ with argument *false*.
+ 1. Let _count_ be the number of elements in the List _cookedStrings_.
+ 1. Let _template_ be ArrayCreate(_count_).
+ 1. Let _rawObj_ be ArrayCreate(_count_).
+ 1. Let _index_ be 0.
+ 1. Repeat while _index_ < _count_
+ 1. Let _prop_ be ToString(_index_).
+ 1. Let _cookedValue_ be the String value _cookedStrings_[_index_].
+ 1. Call _template_.[[DefineOwnProperty]](_prop_, PropertyDescriptor{[[Value]]: _cookedValue_, [[Enumerable]]: *true*, [[Writable]]: *false*, [[Configurable]]: *false*}).
+ 1. Let _rawValue_ be the String value _rawStrings_[_index_].
+ 1. Call _rawObj_.[[DefineOwnProperty]](_prop_, PropertyDescriptor{[[Value]]: _rawValue_, [[Enumerable]]: *true*, [[Writable]]: *false*, [[Configurable]]: *false*}).
+ 1. Let _index_ be _index_+1.
+ 1. Perform SetIntegrityLevel(_rawObj_, `"frozen"`).
+ 1. Call _template_.[[DefineOwnProperty]](`"raw"`, PropertyDescriptor{[[Value]]: _rawObj_, [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Perform SetIntegrityLevel(_template_, `"frozen"`).
+ 1. Append the Record{[[strings]]: _rawStrings_, [[array]]: _template_} to _templateRegistry_.
+ 1. Return _template_.
+
+
+
The creation of a template object cannot result in an abrupt completion.
+
+
+
Each |TemplateLiteral| in the program code of a Realm is associated with a unique template object that is used in the evaluation of tagged Templates (). The template objects are frozen and the same template object is used each time a specific tagged Template is evaluated. Whether template objects are created lazily upon first evaluation of the |TemplateLiteral| or eagerly prior to first evaluation is an implementation choice that is not observable to ECMAScript code.
+
+
+
Future editions of this specification may define additional non-enumerable properties of template objects.
+
+
+
+
+
+
Runtime Semantics: SubstitutionEvaluation
+ TemplateSpans : TemplateTail
+
+ 1. Return an empty List.
+
+ TemplateSpans : TemplateMiddleList TemplateTail
+
+ 1. Return the result of SubstitutionEvaluation of |TemplateMiddleList|.
+
+ TemplateMiddleList : TemplateMiddle Expression
+
+ 1. Let _sub_ be the result of evaluating |Expression|.
+ 1. ReturnIfAbrupt(_sub_).
+ 1. Return a List containing only _sub_.
+
+ TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
+
+ 1. Let _preceding_ be the result of SubstitutionEvaluation of |TemplateMiddleList| .
+ 1. ReturnIfAbrupt(_preceding_).
+ 1. Let _next_ be the result of evaluating |Expression|.
+ 1. ReturnIfAbrupt(_next_).
+ 1. Append _next_ as the last element of the List _preceding_.
+ 1. Return _preceding_.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ TemplateLiteral : NoSubstitutionTemplate
+
+ 1. Return the String value whose code units are the elements of the TV of |NoSubstitutionTemplate| as defined in .
+
+ TemplateLiteral : TemplateHead Expression TemplateSpans
+
+ 1. Let _head_ be the TV of |TemplateHead| as defined in .
+ 1. Let _sub_ be the result of evaluating |Expression|.
+ 1. Let _middle_ be ? ToString(_sub_).
+ 1. Let _tail_ be the result of evaluating |TemplateSpans| .
+ 1. ReturnIfAbrupt(_tail_).
+ 1. Return the String value whose code units are the elements of _head_ followed by the elements of _middle_ followed by the elements of _tail_.
+
+
+
The string conversion semantics applied to the |Expression| value are like `String.prototype.concat` rather than the `+` operator.
+
+ TemplateSpans : TemplateTail
+
+ 1. Let _tail_ be the TV of |TemplateTail| as defined in .
+ 1. Return the string consisting of the code units of _tail_.
+
+ TemplateSpans : TemplateMiddleList TemplateTail
+
+ 1. Let _head_ be the result of evaluating |TemplateMiddleList|.
+ 1. ReturnIfAbrupt(_head_).
+ 1. Let _tail_ be the TV of |TemplateTail| as defined in .
+ 1. Return the string whose code units are the elements of _head_ followed by the elements of _tail_.
+
+ TemplateMiddleList : TemplateMiddle Expression
+
+ 1. Let _head_ be the TV of |TemplateMiddle| as defined in .
+ 1. Let _sub_ be the result of evaluating |Expression|.
+ 1. Let _middle_ be ? ToString(_sub_).
+ 1. Return the sequence of code units consisting of the code units of _head_ followed by the elements of _middle_.
+
+
+
The string conversion semantics applied to the |Expression| value are like `String.prototype.concat` rather than the `+` operator.
+
+ TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
+
+ 1. Let _rest_ be the result of evaluating |TemplateMiddleList| .
+ 1. ReturnIfAbrupt(_rest_).
+ 1. Let _middle_ be the TV of |TemplateMiddle| as defined in .
+ 1. Let _sub_ be the result of evaluating |Expression|.
+ 1. Let _last_ be ? ToString(_sub_).
+ 1. Return the sequence of code units consisting of the elements of _rest_ followed by the code units of _middle_ followed by the elements of _last_.
+
+
+
The string conversion semantics applied to the |Expression| value are like `String.prototype.concat` rather than the `+` operator.
+ It is a Syntax Error if the lexical token sequence matched by |CoverParenthesizedExpressionAndArrowParameterList| cannot be parsed with no tokens left over using |ParenthesizedExpression| as the goal symbol.
+
+
+ All Early Errors rules for |ParenthesizedExpression| and its derived productions also apply to CoveredParenthesizedExpression of |CoverParenthesizedExpressionAndArrowParameterList|.
+
+ PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
+
+ 1. Let _expr_ be CoveredParenthesizedExpression of |CoverParenthesizedExpressionAndArrowParameterList|.
+ 1. Return the result of evaluating _expr_.
+
+ ParenthesizedExpression : `(` Expression `)`
+
+ 1. Return the result of evaluating |Expression|. This may be of type Reference.
+
+
+
This algorithm does not apply GetValue to the result of evaluating |Expression|. The principal motivation for this is so that operators such as `delete` and `typeof` may be applied to parenthesized expressions.
+
+ MemberExpression : MemberExpression `.` IdentifierName
+
+ 1. If |MemberExpression| Contains _symbol_ is *true*, return *true*.
+ 1. If _symbol_ is a |ReservedWord|, return *false*.
+ 1. If _symbol_ is an |Identifier| and StringValue of _symbol_ is the same value as the StringValue of |IdentifierName|, return *true*.
+ 1. Return *false*.
+
+ SuperProperty : `super` `.` IdentifierName
+
+ 1. If _symbol_ is the |ReservedWord| `super`, return *true*.
+ 1. If _symbol_ is a |ReservedWord|, return *false*.
+ 1. If _symbol_ is an |Identifier| and StringValue of _symbol_ is the same value as the StringValue of |IdentifierName|, return *true*.
+ 1. Return *false*.
+
+ CallExpression : CallExpression `.` IdentifierName
+
+ 1. If |CallExpression| Contains _symbol_ is *true*, return *true*.
+ 1. If _symbol_ is a |ReservedWord|, return *false*.
+ 1. If _symbol_ is an |Identifier| and StringValue of _symbol_ is the same value as the StringValue of |IdentifierName|, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
where <identifier-name-string> is the result of evaluating StringValue of |IdentifierName|.
+
+
+
+
+
Runtime Semantics: Evaluation
+ MemberExpression : MemberExpression `[` Expression `]`
+
+ 1. Let _baseReference_ be the result of evaluating |MemberExpression|.
+ 1. Let _baseValue_ be ? GetValue(_baseReference_).
+ 1. Let _propertyNameReference_ be the result of evaluating |Expression|.
+ 1. Let _propertyNameValue_ be ? GetValue(_propertyNameReference_).
+ 1. Let _bv_ be ? RequireObjectCoercible(_baseValue_).
+ 1. Let _propertyKey_ be ? ToPropertyKey(_propertyNameValue_).
+ 1. If the code matched by the syntactic production that is being evaluated is strict mode code, let _strict_ be *true*, else let _strict_ be *false*.
+ 1. Return a value of type Reference whose base value is _bv_ and whose referenced name is _propertyKey_, and whose strict reference flag is _strict_.
+
+ MemberExpression : MemberExpression `.` IdentifierName
+
+ 1. Let _baseReference_ be the result of evaluating |MemberExpression|.
+ 1. Let _baseValue_ be ? GetValue(_baseReference_).
+ 1. Let _bv_ be ? RequireObjectCoercible(_baseValue_).
+ 1. Let _propertyNameString_ be StringValue of |IdentifierName|.
+ 1. If the code matched by the syntactic production that is being evaluated is strict mode code, let _strict_ be *true*, else let _strict_ be *false*.
+ 1. Return a value of type Reference whose base value is _bv_ and whose referenced name is _propertyNameString_, and whose strict reference flag is _strict_.
+
+ CallExpression : CallExpression `[` Expression `]`
+
Is evaluated in exactly the same manner as MemberExpression : MemberExpression `[` Expression `]` except that the contained |CallExpression| is evaluated in step 1.
Is evaluated in exactly the same manner as MemberExpression : MemberExpression `.` IdentifierName except that the contained |CallExpression| is evaluated in step 1.
The abstract operation EvaluateNew with arguments _constructProduction_, and _arguments_ performs the following steps:
+
+ 1. Assert: _constructProduction_ is either a |NewExpression| or a |MemberExpression|.
+ 1. Assert: _arguments_ is either ~empty~ or an |Arguments| production.
+ 1. Let _ref_ be the result of evaluating _constructProduction_.
+ 1. Let _constructor_ be ? GetValue(_ref_).
+ 1. If _arguments_ is ~empty~, let _argList_ be an empty List.
+ 1. Else,
+ 1. Let _argList_ be ArgumentListEvaluation of _arguments_.
+ 1. ReturnIfAbrupt(_argList_).
+ 1. If IsConstructor(_constructor_) is *false*, throw a *TypeError* exception.
+ 1. Return Construct(_constructor_, _argList_).
+
+
+
+
+
+
+
+
Function Calls
+
+
+
+
Runtime Semantics: Evaluation
+ CallExpression : MemberExpression Arguments
+
+ 1. Let _ref_ be the result of evaluating |MemberExpression|.
+ 1. Let _func_ be ? GetValue(_ref_).
+ 1. If Type(_ref_) is Reference and IsPropertyReference(_ref_) is *false* and GetReferencedName(_ref_) is `"eval"`, then
+ 1. If SameValue(_func_, %eval%) is *true*, then
+ 1. Let _argList_ be ? ArgumentListEvaluation(|Arguments|).
+ 1. If _argList_ has no elements, return *undefined*.
+ 1. Let _evalText_ be the first element of _argList_.
+ 1. If the source code matching this |CallExpression| is strict code, let _strictCaller_ be *true*. Otherwise let _strictCaller_ be *false*.
+ 1. Let _evalRealm_ be the running execution context's Realm.
+ 1. Return PerformEval(_evalText_, _evalRealm_, _strictCaller_, *true*).
+ 1. If Type(_ref_) is Reference, then
+ 1. If IsPropertyReference(_ref_) is *true*, then
+ 1. Let _thisValue_ be GetThisValue(_ref_).
+ 1. Else, the base of _ref_ is an Environment Record
+ 1. Let _refEnv_ be GetBase(_ref_).
+ 1. Let _thisValue_ be _refEnv_.WithBaseObject().
+ 1. Else Type(_ref_) is not Reference,
+ 1. Let _thisValue_ be *undefined*.
+ 1. Let _thisCall_ be this |CallExpression|.
+ 1. Let _tailCall_ be IsInTailPosition(_thisCall_). (See )
+ 1. Return EvaluateDirectCall(_func_, _thisValue_, |Arguments|, _tailCall_).
+
+
A |CallExpression| evaluation that executes step 3.a.vi is a direct eval.
+ CallExpression : CallExpression Arguments
+
+ 1. Let _ref_ be the result of evaluating |CallExpression|.
+ 1. Let _thisCall_ be this |CallExpression|.
+ 1. Let _tailCall_ be IsInTailPosition(_thisCall_). (See )
+ 1. Return EvaluateCall(_ref_, |Arguments|, _tailCall_).
+
+
+
+
+
+
The abstract operation EvaluateCall takes as arguments a value _ref_, a syntactic grammar production _arguments_, and a Boolean argument _tailPosition_. It performs the following steps:
+
+ 1. Let _func_ be ? GetValue(_ref_).
+ 1. If Type(_ref_) is Reference, then
+ 1. If IsPropertyReference(_ref_) is *true*, then
+ 1. Let _thisValue_ be GetThisValue(_ref_).
+ 1. Else, the base of _ref_ is an Environment Record
+ 1. Let _refEnv_ be GetBase(_ref_).
+ 1. Let _thisValue_ be _refEnv_.WithBaseObject().
+ 1. Else Type(_ref_) is not Reference,
+ 1. Let _thisValue_ be *undefined*.
+ 1. Return EvaluateDirectCall(_func_, _thisValue_, _arguments_, _tailPosition_).
+
+
+
+
+
+
The abstract operation EvaluateDirectCall takes as arguments a value _func_, a value _thisValue_, a syntactic grammar production _arguments_, and a Boolean argument _tailPosition_. It performs the following steps:
+
+ 1. Let _argList_ be ? ArgumentListEvaluation(_arguments_).
+ 1. If Type(_func_) is not Object, throw a *TypeError* exception.
+ 1. If IsCallable(_func_) is *false*, throw a *TypeError* exception.
+ 1. If _tailPosition_ is *true*, perform PrepareForTailCall().
+ 1. Let _result_ be Call(_func_, _thisValue_, _argList_).
+ 1. Assert: If _tailPosition_ is *true*, the above call will not return here, but instead evaluation will continue as if the following return has already occurred.
+ 1. Assert: If _result_ is not an abrupt completion then Type(_result_) is an ECMAScript language type.
+ 1. Return _result_.
+
+
+
+
+
+
+
The `super` Keyword
+
+
+
+
Runtime Semantics: Evaluation
+ SuperProperty : `super` `[` Expression `]`
+
+ 1. Let _propertyNameReference_ be the result of evaluating |Expression|.
+ 1. Let _propertyNameValue_ be GetValue(_propertyNameReference_).
+ 1. Let _propertyKey_ be ? ToPropertyKey(_propertyNameValue_).
+ 1. If the code matched by the syntactic production that is being evaluated is strict mode code, let _strict_ be *true*, else let _strict_ be *false*.
+ 1. Return MakeSuperPropertyReference(_propertyKey_, _strict_).
+
+ SuperProperty : `super` `.` IdentifierName
+
+ 1. Let _propertyKey_ be StringValue of |IdentifierName|.
+ 1. If the code matched by the syntactic production that is being evaluated is strict mode code, let _strict_ be *true*, else let _strict_ be *false*.
+ 1. Return MakeSuperPropertyReference(_propertyKey_, _strict_).
+
+ SuperCall : `super` Arguments
+
+ 1. Let _newTarget_ be GetNewTarget().
+ 1. If _newTarget_ is *undefined*, throw a *ReferenceError* exception.
+ 1. Let _func_ be ? GetSuperConstructor().
+ 1. Let _argList_ be ArgumentListEvaluation of |Arguments|.
+ 1. ReturnIfAbrupt(_argList_).
+ 1. Let _result_ be ? Construct(_func_, _argList_, _newTarget_).
+ 1. Let _thisER_ be GetThisEnvironment( ).
+ 1. Return _thisER_.BindThisValue(_result_).
+
+
+
+
+
+
Runtime Semantics: GetSuperConstructor ( )
+
The abstract operation GetSuperConstructor performs the following steps:
+
+ 1. Let _envRec_ be GetThisEnvironment( ).
+ 1. Assert: _envRec_ is a function Environment Record.
+ 1. Let _activeFunction_ be _envRec_.[[FunctionObject]].
+ 1. Let _superConstructor_ be ? _activeFunction_.[[GetPrototypeOf]]().
+ 1. If IsConstructor(_superConstructor_) is *false*, throw a *TypeError* exception.
+ 1. Return _superConstructor_.
+
+
+
+
+
+
The abstract operation MakeSuperPropertyReference with arguments _propertyKey_ and _strict_ performs the following steps:
+
+ 1. Let _env_ be GetThisEnvironment( ).
+ 1. If _env_.HasSuperBinding() is *false*, throw a *ReferenceError* exception.
+ 1. Let _actualThis_ be ? _env_.GetThisBinding().
+ 1. Let _baseValue_ be _env_.GetSuperBase().
+ 1. Let _bv_ be ? RequireObjectCoercible(_baseValue_).
+ 1. Return a value of type Reference that is a Super Reference whose base value is _bv_, whose referenced name is _propertyKey_, whose thisValue is _actualThis_, and whose strict reference flag is _strict_.
+
+
+
+
+
+
+
Argument Lists
+
+
The evaluation of an argument list produces a List of values (see ).
+
+
+
+
+
Runtime Semantics: ArgumentListEvaluation
+
+ Arguments : `(` `)`
+
+ 1. Return an empty List.
+
+ ArgumentList : AssignmentExpression
+
+ 1. Let _ref_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _arg_ be ? GetValue(_ref_).
+ 1. Return a List whose sole item is _arg_.
+
+ ArgumentList : `...` AssignmentExpression
+
+ 1. Let _list_ be an empty List.
+ 1. Let _spreadRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _spreadObj_ be GetValue(_spreadRef_).
+ 1. Let _iterator_ be ? GetIterator(_spreadObj_).
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iterator_).
+ 1. If _next_ is *false*, return _list_.
+ 1. Let _nextArg_ be ? IteratorValue(_next_).
+ 1. Append _nextArg_ as the last element of _list_.
+
+ ArgumentList : ArgumentList `,` AssignmentExpression
+
+ 1. Let _precedingArgs_ be the result of evaluating |ArgumentList|.
+ 1. ReturnIfAbrupt(_precedingArgs_).
+ 1. Let _ref_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _arg_ be ? GetValue(_ref_).
+ 1. Append _arg_ to the end of _precedingArgs_.
+ 1. Return _precedingArgs_.
+
+ ArgumentList : ArgumentList `,` `...` AssignmentExpression
+
+ 1. Let _precedingArgs_ be the result of evaluating |ArgumentList|.
+ 1. Let _spreadRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _iterator_ be ? GetIterator(? GetValue(_spreadRef_) ).
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iterator_).
+ 1. If _next_ is *false*, return _precedingArgs_.
+ 1. Let _nextArg_ be ? IteratorValue(_next_).
+ 1. Append _nextArg_ as the last element of _precedingArgs_.
+
+
+
+
+
+
+
Tagged Templates
+
+
A tagged template is a function call where the arguments of the call are derived from a |TemplateLiteral| (). The actual arguments include a template object () and the values produced by evaluating the expressions embedded within the |TemplateLiteral|.
+
+
+
+
+
Runtime Semantics: Evaluation
+ MemberExpression : MemberExpression TemplateLiteral
+
+ 1. Let _tagRef_ be the result of evaluating |MemberExpression|.
+ 1. Let _thisCall_ be this |MemberExpression|.
+ 1. Let _tailCall_ be IsInTailPosition(_thisCall_). (See )
+ 1. Return EvaluateCall(_tagRef_, |TemplateLiteral|, _tailCall_).
+
+ CallExpression : CallExpression TemplateLiteral
+
+ 1. Let _tagRef_ be the result of evaluating |CallExpression|.
+ 1. Let _thisCall_ be this |CallExpression|.
+ 1. Let _tailCall_ be IsInTailPosition(_thisCall_). (See )
+ 1. Return EvaluateCall(_tagRef_, |TemplateLiteral|, _tailCall_).
+
+
+
+
+
+
+
+ PostfixExpression : LeftHandSideExpression `++`
+
+ 1. Let _lhs_ be the result of evaluating |LeftHandSideExpression|.
+ 1. Let _oldValue_ be ? ToNumber(? GetValue(_lhs_)).
+ 1. Let _newValue_ be the result of adding the value `1` to _oldValue_, using the same rules as for the `+` operator (see ).
+ 1. Let _status_ be ? PutValue(_lhs_, _newValue_).
+ 1. Return _oldValue_.
+
+
+
+
+
+
+
Postfix Decrement Operator
+
+
+
+
Runtime Semantics: Evaluation
+ PostfixExpression : LeftHandSideExpression `--`
+
+ 1. Let _lhs_ be the result of evaluating |LeftHandSideExpression|.
+ 1. Let _oldValue_ be ? ToNumber(? GetValue(_lhs_)).
+ 1. Let _newValue_ be the result of subtracting the value `1` from _oldValue_, using the same rules as for the `-` operator ().
+ 1. Let _status_ be ? PutValue(_lhs_, _newValue_).
+ 1. Return _oldValue_.
+
+
+
+
+
+
+
+
+ It is a Syntax Error if the |UnaryExpression| is contained in strict mode code and the derived |UnaryExpression| is PrimaryExpression : IdentifierReference.
+
+
+
It is a Syntax Error if the derived |UnaryExpression| is
+
+ PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
+
+ and |CoverParenthesizedExpressionAndArrowParameterList| ultimately derives a phrase that, if used in place of |UnaryExpression|, would produce a Syntax Error according to these rules. This rule is recursively applied.
+
+
+
+
The last rule means that expressions such as `delete (((foo)))` produce early errors because of recursive application of the first rule.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `delete` UnaryExpression
+
+ 1. Let _ref_ be the result of evaluating |UnaryExpression|.
+ 1. ReturnIfAbrupt(_ref_).
+ 1. If Type(_ref_) is not Reference, return *true*.
+ 1. If IsUnresolvableReference(_ref_) is *true*, then
+ 1. Assert: IsStrictReference(_ref_) is *false*.
+ 1. Return *true*.
+ 1. If IsPropertyReference(_ref_) is *true*, then
+ 1. If IsSuperReference(_ref_), throw a *ReferenceError* exception.
+ 1. Let _baseObj_ be ToObject(GetBase(_ref_)).
+ 1. Assert: _baseObj_ is not an abrupt completion.
+ 1. Let _deleteStatus_ be ? _baseObj_.[[Delete]](GetReferencedName(_ref_)).
+ 1. If _deleteStatus_ is *false* and IsStrictReference(_ref_) is *true*, throw a *TypeError* exception.
+ 1. Return _deleteStatus_.
+ 1. Else _ref_ is a Reference to an Environment Record binding,
+ 1. Let _bindings_ be GetBase(_ref_).
+ 1. Return _bindings_.DeleteBinding(GetReferencedName(_ref_)).
+
+
+
When a `delete` operator occurs within strict mode code, a *SyntaxError* exception is thrown if its |UnaryExpression| is a direct reference to a variable, function argument, or function name. In addition, if a `delete` operator occurs within strict mode code and the property to be deleted has the attribute { [[Configurable]]: *false* }, a *TypeError* exception is thrown.
+
+
+
+
+
+
+
The `void` Operator
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `void` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Let _status_ be ? GetValue(_expr_).
+ 1. Return *undefined*.
+
+
+
GetValue must be called even though its value is not used because it may have observable side-effects.
+
+
+
+
+
+
+
The `typeof` Operator
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `typeof` UnaryExpression
+
+ 1. Let _val_ be the result of evaluating |UnaryExpression|.
+ 1. If Type(_val_) is Reference, then
+ 1. If IsUnresolvableReference(_val_) is *true*, return `"undefined"`.
+ 1. Let _val_ be ? GetValue(_val_).
+ 1. Return a String according to .
+
+
+
+
+
+
+ Type of _val_
+
+
+ Result
+
+
+
+
+ Undefined
+
+
+ `"undefined"`
+
+
+
+
+ Null
+
+
+ `"object"`
+
+
+
+
+ Boolean
+
+
+ `"boolean"`
+
+
+
+
+ Number
+
+
+ `"number"`
+
+
+
+
+ String
+
+
+ `"string"`
+
+
+
+
+ Symbol
+
+
+ `"symbol"`
+
+
+
+
+ Object (ordinary and does not implement [[Call]])
+
+
+ `"object"`
+
+
+
+
+ Object (standard exotic and does not implement [[Call]])
+
+
+ `"object"`
+
+
+
+
+ Object (implements [[Call]])
+
+
+ `"function"`
+
+
+
+
+ Object (non-standard exotic and does not implement [[Call]])
+
+
+ Implementation-defined. Must not be `"undefined"`, `"boolean"`, `"function"`, `"number"`, `"symbol"`, or `"string"`.
+
+
+
+
+
+
+
Implementations are discouraged from defining new `typeof` result values for non-standard exotic objects. If possible `"object"` should be used for such objects.
+
+
+
+
+
+
+
Prefix Increment Operator
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `++` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Let _oldValue_ be ? ToNumber(? GetValue(_expr_)).
+ 1. Let _newValue_ be the result of adding the value `1` to _oldValue_, using the same rules as for the `+` operator (see ).
+ 1. Let _status_ be ? PutValue(_expr_, _newValue_).
+ 1. Return _newValue_.
+
+
+
+
+
+
+
Prefix Decrement Operator
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `--` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Let _oldValue_ be ? ToNumber(? GetValue(_expr_)).
+ 1. Let _newValue_ be the result of subtracting the value `1` from _oldValue_, using the same rules as for the `-` operator (see ).
+ 1. Let _status_ be ? PutValue(_expr_, _newValue_).
+ 1. Return _newValue_.
+
+
+
+
+
+
+
Unary `+` Operator
+
+
The unary + operator converts its operand to Number type.
+
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `+` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Return ToNumber(GetValue(_expr_)).
+
+
+
+
+
+
+
Unary `-` Operator
+
+
The unary `-` operator converts its operand to Number type and then negates it. Negating *+0* produces *-0*, and negating *-0* produces *+0*.
+
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `-` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Let _oldValue_ be ? ToNumber(? GetValue(_expr_)).
+ 1. If _oldValue_ is *NaN*, return *NaN*.
+ 1. Return the result of negating _oldValue_; that is, compute a Number with the same magnitude but opposite sign.
+
+
+
+
+
+
+
Bitwise NOT Operator ( `~` )
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `~` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Let _oldValue_ be ? ToInt32(? GetValue(_expr_)).
+ 1. Return the result of applying bitwise complement to _oldValue_. The result is a signed 32-bit integer.
+
+
+
+
+
+
+
Logical NOT Operator ( `!` )
+
+
+
+
Runtime Semantics: Evaluation
+ UnaryExpression : `!` UnaryExpression
+
+ 1. Let _expr_ be the result of evaluating |UnaryExpression|.
+ 1. Let _oldValue_ be ToBoolean(? GetValue(_expr_)).
+ 1. If _oldValue_ is *true*, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
+
+
+ MultiplicativeExpression : MultiplicativeExpression MultiplicativeOperator UnaryExpression
+
+ 1. Let _left_ be the result of evaluating |MultiplicativeExpression|.
+ 1. Let _leftValue_ be ? GetValue(_left_).
+ 1. Let _right_ be the result of evaluating |UnaryExpression|.
+ 1. Let _rightValue_ be ? GetValue(_right_).
+ 1. Let _lnum_ be ? ToNumber(_leftValue_).
+ 1. Let _rnum_ be ? ToNumber(_rightValue_).
+ 1. Return the result of applying the |MultiplicativeOperator| (*, /, or %) to _lnum_ and _rnum_ as specified in , , or .
+
+
+
+
+
Applying the `*` Operator
+
The `*` |MultiplicativeOperator| performs multiplication, producing the product of its operands. Multiplication is commutative. Multiplication is not always associative in ECMAScript, because of finite precision.
+
The result of a floating-point multiplication is governed by the rules of IEEE 754-2008 binary double-precision arithmetic:
+
+
+ If either operand is *NaN*, the result is *NaN*.
+
+
+ The sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
+
+
+ Multiplication of an infinity by a zero results in *NaN*.
+
+
+ Multiplication of an infinity by an infinity results in an infinity. The sign is determined by the rule already stated above.
+
+
+ Multiplication of an infinity by a finite nonzero value results in a signed infinity. The sign is determined by the rule already stated above.
+
+
+ In the remaining cases, where neither an infinity nor *NaN* is involved, the product is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the result is then an infinity of appropriate sign. If the magnitude is too small to represent, the result is then a zero of appropriate sign. The ECMAScript language requires support of gradual underflow as defined by IEEE 754-2008.
+
+
+
+
+
+
+
Applying the `/` Operator
+
The `/` |MultiplicativeOperator| performs division, producing the quotient of its operands. The left operand is the dividend and the right operand is the divisor. ECMAScript does not perform integer division. The operands and result of all division operations are double-precision floating-point numbers. The result of division is determined by the specification of IEEE 754-2008 arithmetic:
+
+
+ If either operand is *NaN*, the result is *NaN*.
+
+
+ The sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
+
+
+ Division of an infinity by an infinity results in *NaN*.
+
+
+ Division of an infinity by a zero results in an infinity. The sign is determined by the rule already stated above.
+
+
+ Division of an infinity by a nonzero finite value results in a signed infinity. The sign is determined by the rule already stated above.
+
+
+ Division of a finite value by an infinity results in zero. The sign is determined by the rule already stated above.
+
+
+ Division of a zero by a zero results in *NaN*; division of zero by any other finite value results in zero, with the sign determined by the rule already stated above.
+
+
+ Division of a nonzero finite value by a zero results in a signed infinity. The sign is determined by the rule already stated above.
+
+
+ In the remaining cases, where neither an infinity, nor a zero, nor *NaN* is involved, the quotient is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the operation overflows; the result is then an infinity of appropriate sign. If the magnitude is too small to represent, the operation underflows and the result is a zero of the appropriate sign. The ECMAScript language requires support of gradual underflow as defined by IEEE 754-2008.
+
+
+
+
+
+
+
Applying the `%` Operator
+
The `%` |MultiplicativeOperator| yields the remainder of its operands from an implied division; the left operand is the dividend and the right operand is the divisor.
+
+
In C and C++, the remainder operator accepts only integral operands; in ECMAScript, it also accepts floating-point operands.
+
+
The result of a floating-point remainder operation as computed by the `%` operator is not the same as the “remainder” operation defined by IEEE 754-2008. The IEEE 754-2008 “remainder” operation computes the remainder from a rounding division, not a truncating division, and so its behaviour is not analogous to that of the usual integer remainder operator. Instead the ECMAScript language defines `%` on floating-point operations to behave in a manner analogous to that of the Java integer remainder operator; this may be compared with the C library function fmod.
+
The result of an ECMAScript floating-point remainder operation is determined by the rules of IEEE arithmetic:
+
+
+ If either operand is *NaN*, the result is *NaN*.
+
+
+ The sign of the result equals the sign of the dividend.
+
+
+ If the dividend is an infinity, or the divisor is a zero, or both, the result is *NaN*.
+
+
+ If the dividend is finite and the divisor is an infinity, the result equals the dividend.
+
+
+ If the dividend is a zero and the divisor is nonzero and finite, the result is the same as the dividend.
+
+
+ In the remaining cases, where neither an infinity, nor a zero, nor *NaN* is involved, the floating-point remainder r from a dividend n and a divisor d is defined by the mathematical relation r = n - (d × q) where q is an integer that is negative only if n/d is negative and positive only if n/d is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of n and d. r is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.
+
The addition operator either performs string concatenation or numeric addition.
+
+
+
+
+
Runtime Semantics: Evaluation
+ AdditiveExpression : AdditiveExpression `+` MultiplicativeExpression
+
+ 1. Let _lref_ be the result of evaluating |AdditiveExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |MultiplicativeExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _lprim_ be ? ToPrimitive(_lval_).
+ 1. Let _rprim_ be ? ToPrimitive(_rval_).
+ 1. If Type(_lprim_) is String or Type(_rprim_) is String, then
+ 1. Let _lstr_ be ? ToString(_lprim_).
+ 1. Let _rstr_ be ? ToString(_rprim_).
+ 1. Return the String that is the result of concatenating _lstr_ and _rstr_.
+ 1. Let _lnum_ be ? ToNumber(_lprim_).
+ 1. Let _rnum_ be ? ToNumber(_rprim_).
+ 1. Return the result of applying the addition operation to _lnum_ and _rnum_. See the Note below .
+
+
+
No hint is provided in the calls to ToPrimitive in steps 5 and 6. All standard objects except Date objects handle the absence of a hint as if the hint Number were given; Date objects handle the absence of a hint as if the hint String were given. Exotic objects may handle the absence of a hint in some other manner.
+
+
+
Step 7 differs from step 5 of the Abstract Relational Comparison algorithm (), by using the logical-or operation instead of the logical-and operation.
+
+
+
+
+
+
+
The Subtraction Operator ( `-` )
+
+
+
+
Runtime Semantics: Evaluation
+ AdditiveExpression : AdditiveExpression `-` MultiplicativeExpression
+
+ 1. Let _lref_ be the result of evaluating |AdditiveExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |MultiplicativeExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _lnum_ be ? ToNumber(_lval_).
+ 1. Let _rnum_ be ? ToNumber(_rval_).
+ 1. Return the result of applying the subtraction operation to _lnum_ and _rnum_. See the note below .
+
+
+
+
+
+
+
Applying the Additive Operators to Numbers
+
The `+` operator performs addition when applied to two operands of numeric type, producing the sum of the operands. The `-` operator performs subtraction, producing the difference of two numeric operands.
+
Addition is a commutative operation, but not always associative.
+
The result of an addition is determined using the rules of IEEE 754-2008 binary double-precision arithmetic:
+
+
+ If either operand is *NaN*, the result is *NaN*.
+
+
+ The sum of two infinities of opposite sign is *NaN*.
+
+
+ The sum of two infinities of the same sign is the infinity of that sign.
+
+
+ The sum of an infinity and a finite value is equal to the infinite operand.
+
+
+ The sum of two negative zeroes is *-0*. The sum of two positive zeroes, or of two zeroes of opposite sign, is *+0*.
+
+
+ The sum of a zero and a nonzero finite value is equal to the nonzero operand.
+
+
+ The sum of two nonzero finite values of the same magnitude and opposite sign is *+0*.
+
+
+ In the remaining cases, where neither an infinity, nor a zero, nor *NaN* is involved, and the operands have the same sign or have different magnitudes, the sum is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the operation overflows and the result is then an infinity of appropriate sign. The ECMAScript language requires support of gradual underflow as defined by IEEE 754-2008.
+
+
+
+
The `-` operator performs subtraction when applied to two operands of numeric type, producing the difference of its operands; the left operand is the minuend and the right operand is the subtrahend. Given numeric operands `a` and `b`, it is always the case that `a-b` produces the same result as `a+(-b)`.
Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.
+
+
+
+
+
Runtime Semantics: Evaluation
+ ShiftExpression : ShiftExpression `<<` AdditiveExpression
+
+ 1. Let _lref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |AdditiveExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _lnum_ be ? ToInt32(_lval_).
+ 1. Let _rnum_ be ? ToUint32(_rval_).
+ 1. Let _shiftCount_ be the result of masking out all but the least significant 5 bits of _rnum_, that is, compute _rnum_ & 0x1F.
+ 1. Return the result of left shifting _lnum_ by _shiftCount_ bits. The result is a signed 32-bit integer.
+
+
+
+
+
+
+
The Signed Right Shift Operator ( `>>` )
+
+
Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
+
+
+
+
+
Runtime Semantics: Evaluation
+ ShiftExpression : ShiftExpression `>>` AdditiveExpression
+
+ 1. Let _lref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |AdditiveExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _lnum_ be ? ToInt32(_lval_).
+ 1. Let _rnum_ be ? ToUint32(_rval_).
+ 1. Let _shiftCount_ be the result of masking out all but the least significant 5 bits of _rnum_, that is, compute _rnum_ & 0x1F.
+ 1. Return the result of performing a sign-extending right shift of _lnum_ by _shiftCount_ bits. The most significant bit is propagated. The result is a signed 32-bit integer.
+
+
+
+
+
+
+
The Unsigned Right Shift Operator ( `>>>` )
+
+
Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
+
+
+
+
+
Runtime Semantics: Evaluation
+ ShiftExpression : ShiftExpression `>>>` AdditiveExpression
+
+ 1. Let _lref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |AdditiveExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _lnum_ be ? ToUint32(_lval_).
+ 1. Let _rnum_ be ? ToUint32(_rval_).
+ 1. Let _shiftCount_ be the result of masking out all but the least significant 5 bits of _rnum_, that is, compute _rnum_ & 0x1F.
+ 1. Return the result of performing a zero-filling right shift of _lnum_ by _shiftCount_ bits. Vacated bits are filled with zero. The result is an unsigned 32-bit integer.
+
+
+
+
+
+
+
+
Relational Operators
+
+
The result of evaluating a relational operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
+ RelationalExpression : RelationalExpression `<` ShiftExpression
+
+ 1. Let _lref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _rval_ be GetValue(_rref_).
+ 1. Let _r_ be the result of performing Abstract Relational Comparison _lval_ < _rval_. (see )
+ 1. ReturnIfAbrupt(_r_).
+ 1. If _r_ is *undefined*, return *false*. Otherwise, return _r_.
+
+ RelationalExpression : RelationalExpression `>` ShiftExpression
+
+ 1. Let _lref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _rval_ be GetValue(_rref_).
+ 1. Let _r_ be the result of performing Abstract Relational Comparison _rval_ < _lval_ with _LeftFirst_ equal to *false*.
+ 1. ReturnIfAbrupt(_r_).
+ 1. If _r_ is *undefined*, return *false*. Otherwise, return _r_.
+
+ RelationalExpression : RelationalExpression `<=` ShiftExpression
+
+ 1. Let _lref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _rval_ be GetValue(_rref_).
+ 1. Let _r_ be the result of performing Abstract Relational Comparison _rval_ < _lval_ with _LeftFirst_ equal to *false*.
+ 1. ReturnIfAbrupt(_r_).
+ 1. If _r_ is *true* or *undefined*, return *false*. Otherwise, return *true*.
+
+ RelationalExpression : RelationalExpression `>=` ShiftExpression
+
+ 1. Let _lref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _rval_ be GetValue(_rref_).
+ 1. Let _r_ be the result of performing Abstract Relational Comparison _lval_ < _rval_.
+ 1. ReturnIfAbrupt(_r_).
+ 1. If _r_ is *true* or *undefined*, return *false*. Otherwise, return *true*.
+
+ RelationalExpression : RelationalExpression `instanceof` ShiftExpression
+
+ 1. Let _lref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Return InstanceofOperator(_lval_, _rval_).
+
+ RelationalExpression : RelationalExpression `in` ShiftExpression
+
+ 1. Let _lref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |ShiftExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. If Type(_rval_) is not Object, throw a *TypeError* exception.
+ 1. Return HasProperty(_rval_, ToPropertyKey(_lval_)).
+
+
+
+
+
+
Runtime Semantics: InstanceofOperator(_O_, _C_)
+
The abstract operation InstanceofOperator(_O_, _C_) implements the generic algorithm for determining if an object _O_ inherits from the inheritance path defined by constructor _C_. This abstract operation performs the following steps:
+
+ 1. If Type(_C_) is not Object, throw a *TypeError* exception.
+ 1. Let _instOfHandler_ be ? GetMethod(_C_,@@hasInstance).
+ 1. If _instOfHandler_ is not *undefined*, then
+ 1. Return ToBoolean(Call(_instOfHandler_, _C_, « _O_ »)).
+ 1. If IsCallable(_C_) is *false*, throw a *TypeError* exception.
+ 1. Return OrdinaryHasInstance(_C_, _O_).
+
+
+
Steps 5 and 6 provide compatibility with previous editions of ECMAScript that did not use a @@hasInstance method to define the `instanceof` operator semantics. If a function object does not define or inherit @@hasInstance it uses the default `instanceof` semantics.
+
+
+
+
+
+
+
Equality Operators
+
+
The result of evaluating an equality operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
+ EqualityExpression : EqualityExpression `==` RelationalExpression
+
+ 1. Let _lref_ be the result of evaluating |EqualityExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Return the result of performing Abstract Equality Comparison _rval_ == _lval_.
+
+ EqualityExpression : EqualityExpression `!=` RelationalExpression
+
+ 1. Let _lref_ be the result of evaluating |EqualityExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _r_ be the result of performing Abstract Equality Comparison _rval_ == _lval_.
+ 1. If _r_ is *true*, return *false*. Otherwise, return *true*.
+
+ EqualityExpression : EqualityExpression `===` RelationalExpression
+
+ 1. Let _lref_ be the result of evaluating |EqualityExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Return the result of performing Strict Equality Comparison _rval_ === _lval_.
+
+ EqualityExpression : EqualityExpression `!==` RelationalExpression
+
+ 1. Let _lref_ be the result of evaluating |EqualityExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |RelationalExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _r_ be the result of performing Strict Equality Comparison _rval_ === _lval_.
+ 1. If _r_ is *true*, return *false*. Otherwise, return *true*.
+
+
+
Given the above definition of equality:
+
+
+ String comparison can be forced by: `"" + a == "" + b`.
+
+
+ Numeric comparison can be forced by: `+a == +b`.
+
+
+ Boolean comparison can be forced by: `!a == !b`.
+
+
+
+
+
The equality operators maintain the following invariants:
+
+
+ `A != B` is equivalent to `!(A == B)`.
+
+
+ `A == B` is equivalent to `B == A`, except in the order of evaluation of `A` and `B`.
+
+
+
+
+
The equality operator is not always transitive. For example, there might be two distinct String objects, each representing the same String value; each String object would be considered equal to the String value by the `==` operator, but the two String objects would not be equal to each other. For example:
+
+
+ `new String("a") == "a"` and `"a" == new String("a")` are both *true*.
+
+
+ `new String("a") == new String("a")` is *false*.
+
+
+
+
+
Comparison of Strings uses a simple equality test on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore Strings values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form.
The production A : A @ B, where @ is one of the bitwise operators in the productions above, is evaluated as follows:
+
+ 1. Let _lref_ be the result of evaluating _A_.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating _B_.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _lnum_ be ? ToInt32(_lval_).
+ 1. Let _rnum_ be ? ToInt32(_rval_).
+ 1. Return the result of applying the bitwise operator @ to _lnum_ and _rnum_. The result is a signed 32 bit integer.
+
+
+
+
+
+
+
The value produced by a `&&` or `||` operator is not necessarily of type Boolean. The value produced will always be the value of one of the two operand expressions.
+ LogicalANDExpression : LogicalANDExpression `&&` BitwiseORExpression
+
+ 1. Let _lref_ be the result of evaluating |LogicalANDExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _lbool_ be ToBoolean(_lval_).
+ 1. If _lbool_ is *false*, return _lval_.
+ 1. Let _rref_ be the result of evaluating |BitwiseORExpression|.
+ 1. Return GetValue(_rref_).
+
+ LogicalORExpression : LogicalORExpression `||` LogicalANDExpression
+
+ 1. Let _lref_ be the result of evaluating |LogicalORExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _lbool_ be ToBoolean(_lval_).
+ 1. If _lbool_ is *true*, return _lval_.
+ 1. Let _rref_ be the result of evaluating |LogicalANDExpression|.
+ 1. Return GetValue(_rref_).
+
+
+
+
+
+
+
The grammar for a |ConditionalExpression| in ECMAScript is slightly different from that in C and Java, which each allow the second subexpression to be an |Expression| but restrict the third expression to be a |ConditionalExpression|. The motivation for this difference in ECMAScript is to allow an assignment expression to be governed by either arm of a conditional and to eliminate the confusing and fairly useless case of a comma expression as the centre expression.
+ ConditionalExpression : LogicalORExpression `?` AssignmentExpression `:` AssignmentExpression
+
+ 1. Let _lref_ be the result of evaluating |LogicalORExpression|.
+ 1. Let _lval_ be ToBoolean(? GetValue(_lref_)).
+ 1. If _lval_ is *true*, then
+ 1. Let _trueRef_ be the result of evaluating the first |AssignmentExpression|.
+ 1. Return GetValue(_trueRef_).
+ 1. Else,
+ 1. Let _falseRef_ be the result of evaluating the second |AssignmentExpression|.
+ 1. Return GetValue(_falseRef_).
+
+
+
+
+
+
+
+ It is a Syntax Error if |LeftHandSideExpression| is either an |ObjectLiteral| or an |ArrayLiteral| and the lexical token sequence matched by |LeftHandSideExpression| cannot be parsed with no tokens left over using |AssignmentPattern| as the goal symbol.
+
+
+ It is an early Reference Error if |LeftHandSideExpression| is neither an |ObjectLiteral| nor an |ArrayLiteral| and IsValidSimpleAssignmentTarget of |LeftHandSideExpression| is *false*.
+
+ AssignmentExpression[In, Yield] : LeftHandSideExpression[?Yield] `=` AssignmentExpression[?In, ?Yield]
+
+ 1. If |LeftHandSideExpression| is neither an |ObjectLiteral| nor an |ArrayLiteral|, then
+ 1. Let _lref_ be the result of evaluating |LeftHandSideExpression|.
+ 1. ReturnIfAbrupt(_lref_).
+ 1. Let _rref_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. If IsAnonymousFunctionDefinition(|AssignmentExpression|) and IsIdentifierRef of |LeftHandSideExpression| are both *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_rval_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_rval_, GetReferencedName(_lref_)).
+ 1. Let _status_ be ? PutValue(_lref_, _rval_).
+ 1. Return _rval_.
+ 1. Let _assignmentPattern_ be the parse of the source text corresponding to |LeftHandSideExpression| using |AssignmentPattern[?Yield]| as the goal symbol.
+ 1. Let _rref_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _status_ be the result of performing DestructuringAssignmentEvaluation of _assignmentPattern_ using _rval_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return _rval_.
+
+ AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
+
+ 1. Let _lref_ be the result of evaluating |LeftHandSideExpression|.
+ 1. Let _lval_ be ? GetValue(_lref_).
+ 1. Let _rref_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _rval_ be ? GetValue(_rref_).
+ 1. Let _op_ be the `@` where |AssignmentOperator| is `@=`.
+ 1. Let _r_ be the result of applying _op_ to _lval_ and _rval_ as if evaluating the expression _lval_ _op_ _rval_.
+ 1. Let _status_ be ? PutValue(_lref_, _r_).
+ 1. Return _r_.
+
+
+
When an assignment occurs within strict mode code, it is an runtime error if _lref_ in step 1.f of the first algorithm or step 7 of the second algorithm it is an unresolvable reference. If it is, a *ReferenceError* exception is thrown. The |LeftHandSideExpression| also may not be a reference to a data property with the attribute value {[[Writable]]:*false*}, to an accessor property with the attribute value {[[Set]]:*undefined*}, nor to a non-existent property of an object for which the IsExtensible predicate returns the value *false*. In these cases a *TypeError* exception is thrown.
+
+
+
+
+
+
Destructuring Assignment
+
Supplemental Syntax
+
In certain circumstances when processing the production AssignmentExpression : LeftHandSideExpression `=` AssignmentExpression the following grammar is used to refine the interpretation of |LeftHandSideExpression|.
+ It is a Syntax Error if |LeftHandSideExpression| is either an |ObjectLiteral| or an |ArrayLiteral| and if the lexical token sequence matched by |LeftHandSideExpression| cannot be parsed with no tokens left over using |AssignmentPattern| as the goal symbol.
+
+
+ It is a Syntax Error if |LeftHandSideExpression| is neither an |ObjectLiteral| nor an |ArrayLiteral| and IsValidSimpleAssignmentTarget(|LeftHandSideExpression|) is *false*.
+
+ ObjectAssignmentPattern : `{` `}`
+
+ 1. Let _valid_ be ? RequireObjectCoercible(_value_).
+ 1. Return NormalCompletion(~empty~).
+
+
+ ObjectAssignmentPattern :
+ `{` AssignmentPropertyList `}`
+ `{` AssignmentPropertyList `,` `}`
+
+
+ 1. Let _valid_ be ? RequireObjectCoercible(_value_).
+ 1. Return the result of performing DestructuringAssignmentEvaluation for |AssignmentPropertyList| using _value_ as the argument.
+
+ ArrayAssignmentPattern : `[` `]`
+
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Return IteratorClose(_iterator_, NormalCompletion(~empty~)).
+
+ ArrayAssignmentPattern : `[` Elision `]`
+
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. Let _result_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _result_).
+ 1. Return _result_.
+
+ ArrayAssignmentPattern : `[` Elision? AssignmentRestElement `]`
+
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. If |Elision| is present, then
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. If _status_ is an abrupt completion, then
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _status_).
+ 1. Return Completion(_status_).
+ 1. Let _result_ be the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentRestElement| with _iteratorRecord_ as the argument.
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _result_).
+ 1. Return _result_.
+
+ ArrayAssignmentPattern : `[` AssignmentElementList `]`
+
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. Let _result_ be the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElementList| using _iteratorRecord_ as the argument.
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _result_).
+ 1. Return _result_.
+
+ ArrayAssignmentPattern : `[` AssignmentElementList `,` Elision? AssignmentRestElement? `]`
+
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElementList| using _iteratorRecord_ as the argument.
+ 1. If _status_ is an abrupt completion, then
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _status_).
+ 1. Return Completion(_status_).
+ 1. If |Elision| is present, then
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. If _status_ is an abrupt completion, then
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _status_).
+ 1. Return Completion(_status_).
+ 1. If |AssignmentRestElement| is present, then
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentRestElement| with _iteratorRecord_ as the argument.
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _status_).
+ 1. Return Completion(_status_).
+
+ AssignmentPropertyList : AssignmentPropertyList `,` AssignmentProperty
+
+ 1. Let _status_ be the result of performing DestructuringAssignmentEvaluation for |AssignmentPropertyList| using _value_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing DestructuringAssignmentEvaluation for |AssignmentProperty| using _value_ as the argument.
+
+ AssignmentProperty : IdentifierReference Initializer?
+
+ 1. Let _P_ be StringValue of |IdentifierReference|.
+ 1. Let _lref_ be ? ResolveBinding(_P_).
+ 1. Let _v_ be ? GetV(_value_, _P_).
+ 1. If |Initializer_opt| is present and _v_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _v_ be ? GetValue(_defaultValue_).
+ 1. If IsAnonymousFunctionDefinition(|Initializer|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_v_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_v_, _P_).
+ 1. Return PutValue(_lref_,_v_).
+
+ AssignmentProperty : PropertyName `:` AssignmentElement
+
+ 1. Let _name_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_name_).
+ 1. Return the result of performing KeyedDestructuringAssignmentEvaluation of |AssignmentElement| with _value_ and _name_ as the arguments.
+
+
+
+
+
+
+ AssignmentElementList : AssignmentElisionElement
+
+ 1. Return the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElisionElement| using _iteratorRecord_ as the _argument_.
+
+ AssignmentElementList : AssignmentElementList `,` AssignmentElisionElement
+
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElementList| using _iteratorRecord_ as the _argument_.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElisionElement| using _iteratorRecord_ as the _argument_.
+
+ AssignmentElisionElement : AssignmentElement
+
+ 1. Return the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElement| with _iteratorRecord_ as the argument.
+
+ AssignmentElisionElement : Elision AssignmentElement
+
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorDestructuringAssignmentEvaluation of |AssignmentElement| with _iteratorRecord_ as the argument.
+
+ Elision : `,`
+
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Return NormalCompletion(~empty~).
+
+ Elision : Elision `,`
+
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Return NormalCompletion(~empty~).
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializer?
+
+ 1. If |DestructuringAssignmentTarget| is neither an |ObjectLiteral| nor an |ArrayLiteral|, then
+ 1. Let _lref_ be the result of evaluating |DestructuringAssignmentTarget|.
+ 1. ReturnIfAbrupt(_lref_).
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Else,
+ 1. Let _value_ be IteratorValue(_next_).
+ 1. If _value_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_value_).
+ 1. If _iteratorRecord_.[[done]] is *true*, let _value_ be *undefined*.
+ 1. If |Initializer| is present and _value_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _v_ be ? GetValue(_defaultValue_).
+ 1. Else, let _v_ be _value_.
+ 1. If |DestructuringAssignmentTarget| is an |ObjectLiteral| or an |ArrayLiteral|, then
+ 1. Let _nestedAssignmentPattern_ be the parse of the source text corresponding to |DestructuringAssignmentTarget| using either |AssignmentPattern| or |AssignmentPattern[Yield]| as the goal symbol depending upon whether this |AssignmentElement| has the [Yield] parameter.
+ 1. Return the result of performing DestructuringAssignmentEvaluation of _nestedAssignmentPattern_ with _v_ as the argument.
+ 1. If |Initializer| is present and _value_ is *undefined* and IsAnonymousFunctionDefinition(|Initializer|) and IsIdentifierRef of |DestructuringAssignmentTarget| are both *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_v_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_v_, GetReferencedName(_lref_)).
+ 1. Return PutValue(_lref_, _v_).
+
+
+
Left to right evaluation order is maintained by evaluating a |DestructuringAssignmentTarget| that is not a destructuring pattern prior to accessing the iterator or evaluating the |Initializer|.
+
+ AssignmentRestElement[Yield] : `...` DestructuringAssignmentTarget
+
+ 1. If |DestructuringAssignmentTarget| is neither an |ObjectLiteral| nor an |ArrayLiteral|, then
+ 1. Let _lref_ be the result of evaluating |DestructuringAssignmentTarget|.
+ 1. ReturnIfAbrupt(_lref_).
+ 1. Let _A_ be ArrayCreate(0).
+ 1. Let _n_ be 0.
+ 1. Repeat while _iteratorRecord_.[[done]] is *false*,
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Else,
+ 1. Let _nextValue_ be IteratorValue(_next_).
+ 1. If _nextValue_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_nextValue_).
+ 1. Let _status_ be CreateDataProperty(_A_, ToString(_n_), _nextValue_).
+ 1. Assert: _status_ is *true*.
+ 1. Increment _n_ by 1.
+ 1. If |DestructuringAssignmentTarget| is neither an |ObjectLiteral| nor an |ArrayLiteral|, then
+ 1. Return PutValue(_lref_, _A_).
+ 1. Let _nestedAssignmentPattern_ be the parse of the source text corresponding to |DestructuringAssignmentTarget| using either |AssignmentPattern| or |AssignmentPattern[Yield]| as the goal symbol depending upon whether this |AssignmentElement| has the [Yield] parameter.
+ 1. Return the result of performing DestructuringAssignmentEvaluation of _nestedAssignmentPattern_ with _A_ as the argument.
+
+
+
+
+
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializer?
+
+ 1. If |DestructuringAssignmentTarget| is neither an |ObjectLiteral| nor an |ArrayLiteral|, then
+ 1. Let _lref_ be the result of evaluating |DestructuringAssignmentTarget|.
+ 1. ReturnIfAbrupt(_lref_).
+ 1. Let _v_ be ? GetV(_value_, _propertyName_).
+ 1. If |Initializer| is present and _v_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _rhsValue_ be ? GetValue(_defaultValue_).
+ 1. Else, let _rhsValue_ be _v_.
+ 1. If |DestructuringAssignmentTarget| is an |ObjectLiteral| or an |ArrayLiteral|, then
+ 1. Let _assignmentPattern_ be the parse of the source text corresponding to |DestructuringAssignmentTarget| using either |AssignmentPattern| or |AssignmentPattern[Yield]| as the goal symbol depending upon whether this |AssignmentElement| has the [Yield] parameter.
+ 1. Return the result of performing DestructuringAssignmentEvaluation of _assignmentPattern_ with _rhsValue_ as the argument.
+ 1. If |Initializer| is present and _v_ is *undefined* and IsAnonymousFunctionDefinition(|Initializer|) and IsIdentifierRef of |DestructuringAssignmentTarget| are both *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_rhsValue_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_rhsValue_, GetReferencedName(_lref_)).
+ 1. Return PutValue(_lref_, _rhsValue_).
+
+
+
+
+
+
+
+
+ Expression : Expression `,` AssignmentExpression
+
+ 1. Let _lref_ be the result of evaluating |Expression|.
+ 1. ReturnIfAbrupt(GetValue(_lref_)).
+ 1. Let _rref_ be the result of evaluating |AssignmentExpression|.
+ 1. Return GetValue(_rref_).
+
+
+
GetValue must be called even though its value is not used because it may have observable side-effects.
+
+ BreakableStatement : IterationStatement
+
+ 1. Let _stmtResult_ be the result of performing LabelledEvaluation of |IterationStatement| with argument _labelSet_.
+ 1. If _stmtResult_.[[type]] is ~break~, then
+ 1. If _stmtResult_.[[target]] is ~empty~, then
+ 1. If _stmtResult_.[[value]] is ~empty~, let _stmtResult_ be NormalCompletion(*undefined*).
+ 1. Else, let _stmtResult_ be NormalCompletion(_stmtResult_.[[value]]).
+ 1. Return Completion(_stmtResult_).
+
+ BreakableStatement : SwitchStatement
+
+ 1. Let _stmtResult_ be the result of evaluating |SwitchStatement|.
+ 1. If _stmtResult_.[[type]] is ~break~, then
+ 1. If _stmtResult_.[[target]] is ~empty~, then
+ 1. If _stmtResult_.[[value]] is ~empty~, let _stmtResult_ be NormalCompletion(*undefined*).
+ 1. Else, let _stmtResult_ be NormalCompletion(_stmtResult_.[[value]]).
+ 1. Return Completion(_stmtResult_).
+
+
+
A |BreakableStatement| is one that can be exited via an unlabelled |BreakStatement|.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+
+ HoistableDeclaration :
+ GeneratorDeclaration
+
+
+ 1. Return NormalCompletion(~empty~).
+
+
+ HoistableDeclaration :
+ FunctionDeclaration
+
+
+ 1. Return the result of evaluating |FunctionDeclaration|.
+
+
+ BreakableStatement :
+ IterationStatement
+ SwitchStatement
+
+
+ 1. Let _newLabelSet_ be a new empty List.
+ 1. Return the result of performing LabelledEvaluation of this |BreakableStatement| with argument _newLabelSet_.
+
+
+
+
+
+
+
+ It is a Syntax Error if the LexicallyDeclaredNames of |StatementList| contains any duplicate entries.
+
+
+ It is a Syntax Error if any element of the LexicallyDeclaredNames of |StatementList| also occurs in the VarDeclaredNames of |StatementList|.
+
+
+
+
+
+
+
Static Semantics: ContainsDuplicateLabels
+
With argument _labelSet_.
+
+ Block : `{` `}`
+
+ 1. Return *false*.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |StatementList| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of |StatementListItem| with argument _labelSet_.
+
+ StatementListItem : Declaration
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ Block : `{` `}`
+
+ 1. Return *false*.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |StatementList| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of |StatementListItem| with argument _labelSet_.
+
+ StatementListItem : Declaration
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ Block : `{` `}`
+
+ 1. Return *false*.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |StatementList| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of |StatementListItem| with arguments _iterationSet_ and « ».
+
+ StatementListItem : Declaration
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: LexicallyDeclaredNames
+
+ Block : `{` `}`
+
+ 1. Return a new empty List.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _names_ be LexicallyDeclaredNames of |StatementList|.
+ 1. Append to _names_ the elements of the LexicallyDeclaredNames of |StatementListItem|.
+ 1. Return _names_.
+
+ StatementListItem : Statement
+
+ 1. If |Statement| is Statement : LabelledStatement , return LexicallyDeclaredNames of |LabelledStatement|.
+ 1. Return a new empty List.
+
+ StatementListItem : Declaration
+
+ 1. Return the BoundNames of |Declaration|.
+
+
+
+
+
+
Static Semantics: LexicallyScopedDeclarations
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _declarations_ be LexicallyScopedDeclarations of |StatementList|.
+ 1. Append to _declarations_ the elements of the LexicallyScopedDeclarations of |StatementListItem|.
+ 1. Return _declarations_.
+
+ StatementListItem : Statement
+
+ 1. If |Statement| is Statement : LabelledStatement , return LexicallyScopedDeclarations of |LabelledStatement|.
+ 1. Return a new empty List.
+
+ StatementListItem : Declaration
+
+ 1. Return a new List containing DeclarationPart of |Declaration|.
+
+
+
+
+
+
Static Semantics: TopLevelLexicallyDeclaredNames
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _names_ be TopLevelLexicallyDeclaredNames of |StatementList|.
+ 1. Append to _names_ the elements of the TopLevelLexicallyDeclaredNames of |StatementListItem|.
+ 1. Return _names_.
+
+ StatementListItem : Statement
+
+ 1. Return a new empty List.
+
+ StatementListItem : Declaration
+
+ 1. If |Declaration| is Declaration : HoistableDeclaration , then
+ 1. Return « ».
+ 1. Return the BoundNames of |Declaration|.
+
+
+
At the top level of a function, or script, function declarations are treated like var declarations rather than like lexical declarations.
+
+ Block : `{` `}`
+
+ 1. Return a new empty List.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _declarations_ be TopLevelLexicallyScopedDeclarations of |StatementList|.
+ 1. Append to _declarations_ the elements of the TopLevelLexicallyScopedDeclarations of |StatementListItem|.
+ 1. Return _declarations_.
+
+ StatementListItem : Statement
+
+ 1. Return a new empty List.
+
+ StatementListItem : Declaration
+
+ 1. If |Declaration| is Declaration : HoistableDeclaration , then
+ 1. Return « ».
+ 1. Return a new List containing |Declaration|.
+
+
+
+
+
+
Static Semantics: TopLevelVarDeclaredNames
+
+ Block : `{` `}`
+
+ 1. Return a new empty List.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _names_ be TopLevelVarDeclaredNames of |StatementList|.
+ 1. Append to _names_ the elements of the TopLevelVarDeclaredNames of |StatementListItem|.
+ 1. Return _names_.
+
+ StatementListItem : Declaration
+
+ 1. If |Declaration| is Declaration : HoistableDeclaration , then
+ 1. Return the BoundNames of |HoistableDeclaration|.
+ 1. Return a new empty List.
+
+ StatementListItem : Statement
+
+ 1. If |Statement| is Statement : LabelledStatement , return TopLevelVarDeclaredNames of |Statement|.
+ 1. Return VarDeclaredNames of |Statement|.
+
+
+
At the top level of a function or script, inner function declarations are treated like var declarations.
+
+
+
+
+
+
Static Semantics: TopLevelVarScopedDeclarations
+
+ Block : `{` `}`
+
+ 1. Return a new empty List.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _declarations_ be TopLevelVarScopedDeclarations of |StatementList|.
+ 1. Append to _declarations_ the elements of the TopLevelVarScopedDeclarations of |StatementListItem|.
+ 1. Return _declarations_.
+
+ StatementListItem : Statement
+
+ 1. If |Statement| is Statement : LabelledStatement , return TopLevelVarScopedDeclarations of |Statement|.
+ 1. Return VarScopedDeclarations of |Statement|.
+
+ StatementListItem : Declaration
+
+ 1. If |Declaration| is Declaration : HoistableDeclaration , then
+ 1. Let _declaration_ be DeclarationPart of |HoistableDeclaration|.
+ 1. Return « _declaration_ ».
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: VarDeclaredNames
+
+ Block : `{` `}`
+
+ 1. Return a new empty List.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _names_ be VarDeclaredNames of |StatementList|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |StatementListItem|.
+ 1. Return _names_.
+
+ StatementListItem : Declaration
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ Block : `{` `}`
+
+ 1. Return a new empty List.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _declarations_ be VarScopedDeclarations of |StatementList|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |StatementListItem|.
+ 1. Return _declarations_.
+
+ StatementListItem : Declaration
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ Block : `{` `}`
+
+ 1. Return NormalCompletion(~empty~).
+
+ Block : `{` StatementList `}`
+
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _blockEnv_ be NewDeclarativeEnvironment(_oldEnv_).
+ 1. Perform BlockDeclarationInstantiation(|StatementList|, _blockEnv_).
+ 1. Set the running execution context's LexicalEnvironment to _blockEnv_.
+ 1. Let _blockValue_ be the result of evaluating |StatementList|.
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return _blockValue_.
+
+
+
No matter how control leaves the |Block| the LexicalEnvironment is always restored to its former state.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _sl_ be the result of evaluating |StatementList|.
+ 1. ReturnIfAbrupt(_sl_).
+ 1. Let _s_ be the result of evaluating |StatementListItem|.
+ 1. Return Completion(UpdateEmpty(_s_, _sl_)).
+
+
+
The value of a |StatementList| is the value of the last value producing item in the |StatementList|. For example, the following calls to the `eval` function all return the value 1:
When a |Block| or |CaseBlock| production is evaluated a new declarative Environment Record is created and bindings for each block scoped variable, constant, function, generator function, or class declared in the block are instantiated in the Environment Record.
+
+
BlockDeclarationInstantiation is performed as follows using arguments _code_ and _env_. _code_ is the grammar production corresponding to the body of the block. _env_ is the declarative Environment Record in which bindings are to be created.
+
+ 1. Let _declarations_ be the LexicallyScopedDeclarations of _code_.
+ 1. For each element _d_ in _declarations_ do
+ 1. For each element _dn_ of the BoundNames of _d_ do
+ 1. If IsConstantDeclaration of _d_ is *true*, then
+ 1. Let _status_ be _env_.CreateImmutableBinding(_dn_, *true*).
+ 1. Else,
+ 1. Let _status_ be _env_.CreateMutableBinding(_dn_, *false*).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. If _d_ is a |GeneratorDeclaration| production or a |FunctionDeclaration| production, then
+ 1. Let _fn_ be the sole element of the BoundNames of _d_.
+ 1. Let _fo_ be the result of performing InstantiateFunctionObject for _d_ with argument _env_.
+ 1. Perform _env_.InitializeBinding(_fn_, _fo_).
+
+
+
+
+
+
+
Declarations and the Variable Statement
+
+
+
+
Let and Const Declarations
+
+
`let` and `const` declarations define variables that are scoped to the running execution context's LexicalEnvironment. The variables are created when their containing Lexical Environment is instantiated but may not be accessed in any way until the variable's |LexicalBinding| is evaluated. A variable defined by a |LexicalBinding| with an |Initializer| is assigned the value of its |Initializer|'s |AssignmentExpression| when the |LexicalBinding| is evaluated, not when the variable is created. If a |LexicalBinding| in a `let` declaration does not have an |Initializer| the variable is assigned the value *undefined* when the |LexicalBinding| is evaluated.
+ LexicalDeclaration : LetOrConst BindingList `;`
+
+ 1. Let _next_ be the result of evaluating |BindingList|.
+ 1. ReturnIfAbrupt(_next_).
+ 1. Return NormalCompletion(~empty~).
+
+ BindingList : BindingList `,` LexicalBinding
+
+ 1. Let _next_ be the result of evaluating |BindingList|.
+ 1. ReturnIfAbrupt(_next_).
+ 1. Return the result of evaluating |LexicalBinding|.
+
+ LexicalBinding : BindingIdentifier
+
+ 1. Let _lhs_ be ResolveBinding(StringValue of |BindingIdentifier|).
+ 1. Return InitializeReferencedBinding(_lhs_, *undefined*).
+
+
+
A static semantics rule ensures that this form of |LexicalBinding| never occurs in a `const` declaration.
+
+ LexicalBinding : BindingIdentifier Initializer
+
+ 1. Let _bindingId_ be StringValue of |BindingIdentifier|.
+ 1. Let _lhs_ be ResolveBinding(_bindingId_).
+ 1. Let _rhs_ be the result of evaluating |Initializer|.
+ 1. Let _value_ be ? GetValue(_rhs_).
+ 1. If IsAnonymousFunctionDefinition(|Initializer|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_value_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_value_, _bindingId_).
+ 1. Return InitializeReferencedBinding(_lhs_, _value_).
+
+ LexicalBinding : BindingPattern Initializer
+
+ 1. Let _rhs_ be the result of evaluating |Initializer|.
+ 1. Let _value_ be ? GetValue(_rhs_).
+ 1. Let _env_ be the running execution context's LexicalEnvironment.
+ 1. Return the result of performing BindingInitialization for |BindingPattern| using _value_ and _env_ as the _arguments_.
+
+
+
+
+
+
+
Variable Statement
+
+
A `var` statement declares variables that are scoped to the running execution context's VariableEnvironment. Var variables are created when their containing Lexical Environment is instantiated and are initialized to *undefined* when created. Within the scope of any VariableEnvironment a common |BindingIdentifier| may appear in more than one |VariableDeclaration| but those declarations collective define only one variable. A variable defined by a |VariableDeclaration| with an |Initializer| is assigned the value of its |Initializer|'s |AssignmentExpression| when the |VariableDeclaration| is executed, not when the variable is created.
+
+ VariableDeclarationList : VariableDeclaration
+
+ 1. Return a new List containing |VariableDeclaration|.
+
+ VariableDeclarationList : VariableDeclarationList `,` VariableDeclaration
+
+ 1. Let _declarations_ be VarScopedDeclarations of |VariableDeclarationList|.
+ 1. Append |VariableDeclaration| to _declarations_.
+ 1. Return _declarations_.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ VariableStatement : `var` VariableDeclarationList `;`
+
+ 1. Let _next_ be the result of evaluating |VariableDeclarationList|.
+ 1. ReturnIfAbrupt(_next_).
+ 1. Return NormalCompletion( ~empty~).
+
+ VariableDeclarationList : VariableDeclarationList `,` VariableDeclaration
+
+ 1. Let _next_ be the result of evaluating |VariableDeclarationList|.
+ 1. ReturnIfAbrupt(_next_).
+ 1. Return the result of evaluating |VariableDeclaration|.
+
+ VariableDeclaration : BindingIdentifier
+
+ 1. Return NormalCompletion(~empty~).
+
+ VariableDeclaration : BindingIdentifier Initializer
+
+ 1. Let _bindingId_ be StringValue of |BindingIdentifier|.
+ 1. Let _lhs_ be ? ResolveBinding(_bindingId_).
+ 1. Let _rhs_ be the result of evaluating |Initializer|.
+ 1. Let _value_ be ? GetValue(_rhs_).
+ 1. If IsAnonymousFunctionDefinition(|Initializer|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_value_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_value_, _bindingId_).
+ 1. Return PutValue(_lhs_, _value_).
+
+
+
If a |VariableDeclaration| is nested within a with statement and the |BindingIdentifier| in the |VariableDeclaration| is the same as a property name of the binding object of the with statement's object Environment Record, then step 6 will assign _value_ to the property instead of assigning to the VariableEnvironment binding of the |Identifier|.
+
+ VariableDeclaration : BindingPattern Initializer
+
+ 1. Let _rhs_ be the result of evaluating |Initializer|.
+ 1. Let _rval_ be ? GetValue(_rhs_).
+ 1. Return the result of performing BindingInitialization for |BindingPattern| passing _rval_ and *undefined* as arguments.
+
+
+
+
+
+
+
When *undefined* is passed for _environment_ it indicates that a PutValue operation should be used to assign the initialization value. This is the case for formal parameter lists of non-strict functions. In that case the formal parameter bindings are preinitialized in order to deal with the possibility of multiple parameters with the same name.
+
+ BindingPattern : ObjectBindingPattern
+
+ 1. Let _valid_ be ? RequireObjectCoercible(_value_).
+ 1. Return the result of performing BindingInitialization for |ObjectBindingPattern| using _value_ and _environment_ as arguments.
+
+ BindingPattern : ArrayBindingPattern
+
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. Let _result_ be IteratorBindingInitialization for |ArrayBindingPattern| using _iteratorRecord_, and _environment_ as arguments.
+ 1. If _iteratorRecord_.[[done]] is *false*, return IteratorClose(_iterator_, _result_).
+ 1. Return _result_.
+
+ ObjectBindingPattern : `{` `}`
+
+ 1. Return NormalCompletion(~empty~).
+
+ BindingPropertyList : BindingPropertyList `,` BindingProperty
+
+ 1. Let _status_ be the result of performing BindingInitialization for |BindingPropertyList| using _value_ and _environment_ as arguments.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing BindingInitialization for |BindingProperty| using _value_ and _environment_ as arguments.
+
+ BindingProperty : SingleNameBinding
+
+ 1. Let _name_ be the string that is the only element of BoundNames of |SingleNameBinding|.
+ 1. Return the result of performing KeyedBindingInitialization for |SingleNameBinding| using _value_, _environment_, and _name_ as the arguments.
+
+ BindingProperty : PropertyName `:` BindingElement
+
+ 1. Let _P_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_P_).
+ 1. Return the result of performing KeyedBindingInitialization for |BindingElement| using _value_, _environment_, and _P_ as arguments.
+
+
+
+
+
+
Runtime Semantics: IteratorBindingInitialization
+
With parameters _iteratorRecord_, and _environment_.
+
+
+
When *undefined* is passed for _environment_ it indicates that a PutValue operation should be used to assign the initialization value. This is the case for formal parameter lists of non-strict functions. In that case the formal parameter bindings are preinitialized in order to deal with the possibility of multiple parameters with the same name.
+
+ ArrayBindingPattern : `[` `]`
+
+ 1. Return NormalCompletion(~empty~).
+
+ ArrayBindingPattern : `[` Elision `]`
+
+ 1. Return the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+
+ ArrayBindingPattern : `[` Elision? BindingRestElement `]`
+
+ 1. If |Elision| is present, then
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorBindingInitialization for |BindingRestElement| with _iteratorRecord_ and _environment_ as arguments.
+
+ ArrayBindingPattern : `[` BindingElementList `]`
+
+ 1. Return the result of performing IteratorBindingInitialization for |BindingElementList| with _iteratorRecord_ and _environment_ as arguments.
+
+ ArrayBindingPattern : `[` BindingElementList `,` `]`
+
+ 1. Return the result of performing IteratorBindingInitialization for |BindingElementList| with _iteratorRecord_ and _environment_ as arguments.
+
+ ArrayBindingPattern : `[` BindingElementList `,` Elision `]`
+
+ 1. Let _status_ be the result of performing IteratorBindingInitialization for |BindingElementList| with _iteratorRecord_ and _environment_ as arguments.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+
+ ArrayBindingPattern : `[` BindingElementList `,` Elision? BindingRestElement `]`
+
+ 1. Let _status_ be the result of performing IteratorBindingInitialization for |BindingElementList| with _iteratorRecord_ and _environment_ as arguments.
+ 1. ReturnIfAbrupt(_status_).
+ 1. If |Elision| is present, then
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorBindingInitialization for |BindingRestElement| with _iteratorRecord_ and _environment_ as arguments.
+
+ BindingElementList : BindingElisionElement
+
+ 1. Return the result of performing IteratorBindingInitialization for |BindingElisionElement| with _iteratorRecord_ and _environment_ as arguments.
+
+ BindingElementList : BindingElementList `,` BindingElisionElement
+
+ 1. Let _status_ be the result of performing IteratorBindingInitialization for |BindingElementList| with _iteratorRecord_ and _environment_ as arguments.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorBindingInitialization for |BindingElisionElement| using _iteratorRecord_ and _environment_ as arguments.
+
+ BindingElisionElement : BindingElement
+
+ 1. Return the result of performing IteratorBindingInitialization of |BindingElement| with _iteratorRecord_ and _environment_ as the arguments.
+
+ BindingElisionElement : Elision BindingElement
+
+ 1. Let _status_ be the result of performing IteratorDestructuringAssignmentEvaluation of |Elision| with _iteratorRecord_ as the argument.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorBindingInitialization of |BindingElement| with _iteratorRecord_ and _environment_ as the arguments.
+
+ BindingElement : SingleNameBinding
+
+ 1. Return the result of performing IteratorBindingInitialization for |SingleNameBinding| with _iteratorRecord_ and _environment_ as the arguments.
+
+ SingleNameBinding : BindingIdentifier Initializer?
+
+ 1. Let _bindingId_ be StringValue of |BindingIdentifier|.
+ 1. Let _lhs_ be ? ResolveBinding(_bindingId_, _environment_).
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Else,
+ 1. Let _v_ be IteratorValue(_next_).
+ 1. If _v_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_v_).
+ 1. If _iteratorRecord_.[[done]] is *true*, let _v_ be *undefined*.
+ 1. If |Initializer| is present and _v_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _v_ be ? GetValue(_defaultValue_).
+ 1. If IsAnonymousFunctionDefinition(|Initializer|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_v_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_v_, _bindingId_).
+ 1. If _environment_ is *undefined*, return PutValue(_lhs_, _v_).
+ 1. Return InitializeReferencedBinding(_lhs_, _v_).
+
+ BindingElement : BindingPattern Initializer?
+
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Else,
+ 1. Let _v_ be IteratorValue(_next_).
+ 1. If _v_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_v_).
+ 1. If _iteratorRecord_.[[done]] is *true*, let _v_ be *undefined*.
+ 1. If |Initializer| is present and _v_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _v_ be ? GetValue(_defaultValue_).
+ 1. Return the result of performing BindingInitialization of |BindingPattern| with _v_ and _environment_ as the arguments.
+
+ BindingRestElement : `...` BindingIdentifier
+
+ 1. Let _lhs_ be ? ResolveBinding(StringValue of |BindingIdentifier|, _environment_).
+ 1. Let _A_ be ArrayCreate(0).
+ 1. Let _n_ be 0.
+ 1. Repeat,
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. If _iteratorRecord_.[[done]] is *true*, then
+ 1. If _environment_ is *undefined*, return PutValue(_lhs_, _A_).
+ 1. Return InitializeReferencedBinding(_lhs_, _A_).
+ 1. Let _nextValue_ be IteratorValue(_next_).
+ 1. If _nextValue_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_nextValue_).
+ 1. Let _status_ be CreateDataProperty(_A_, ToString(_n_), _nextValue_).
+ 1. Assert: _status_ is *true*.
+ 1. Increment _n_ by 1.
+
+ BindingRestElement : `...` BindingPattern
+
+ 1. Let _A_ be ArrayCreate(0).
+ 1. Let _n_ be 0.
+ 1. Repeat,
+ 1. If _iteratorRecord_.[[done]] is *false*, then
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. If _iteratorRecord_.[[done]] is *true*, then
+ 1. Return the result of performing BindingInitialization of |BindingPattern| with _A_ and _environment_ as the arguments.
+ 1. Let _nextValue_ be IteratorValue(_next_).
+ 1. If _nextValue_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_nextValue_).
+ 1. Let _status_ be CreateDataProperty(_A_, ToString(_n_), _nextValue_).
+ 1. Assert: _status_ is *true*.
+ 1. Increment _n_ by 1.
+
+
+
+
+
+
Runtime Semantics: KeyedBindingInitialization
+
With parameters _value_, _environment_, and _propertyName_.
+
+
When *undefined* is passed for _environment_ it indicates that a PutValue operation should be used to assign the initialization value. This is the case for formal parameter lists of non-strict functions. In that case the formal parameter bindings are preinitialized in order to deal with the possibility of multiple parameters with the same name.
+
+ BindingElement : BindingPattern Initializer?
+
+ 1. Let _v_ be ? GetV(_value_, _propertyName_).
+ 1. If |Initializer| is present and _v_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _v_ be ? GetValue(_defaultValue_).
+ 1. Return the result of performing BindingInitialization for |BindingPattern| passing _v_ and _environment_ as arguments.
+
+ SingleNameBinding : BindingIdentifier Initializer?
+
+ 1. Let _bindingId_ be StringValue of |BindingIdentifier|.
+ 1. Let _lhs_ be ? ResolveBinding(_bindingId_, _environment_).
+ 1. Let _v_ be ? GetV(_value_, _propertyName_).
+ 1. If |Initializer| is present and _v_ is *undefined*, then
+ 1. Let _defaultValue_ be the result of evaluating |Initializer|.
+ 1. Let _v_ be ? GetValue(_defaultValue_).
+ 1. If IsAnonymousFunctionDefinition(|Initializer|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_v_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_v_, _bindingId_).
+ 1. If _environment_ is *undefined*, return PutValue(_lhs_, _v_).
+ 1. Return InitializeReferencedBinding(_lhs_, _v_).
+
+
+
+
+
+
+
+
An |ExpressionStatement| cannot start with a U+007B (LEFT CURLY BRACKET) because that might make it ambiguous with a |Block|. Also, an |ExpressionStatement| cannot start with the `function` or `class` keywords because that would make it ambiguous with a |FunctionDeclaration|, a |GeneratorDeclaration|, or a |ClassDeclaration|. An |ExpressionStatement| cannot start with the two token sequence `let [` because that would make it ambiguous with a `let` |LexicalDeclaration| whose first |LexicalBinding| was an |ArrayBindingPattern|.
+
+
+
+
+
Runtime Semantics: Evaluation
+ ExpressionStatement : Expression `;`
+
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Return GetValue(_exprRef_).
+
+
+
+
+
+
+
Each `else` for which the choice of associated `if` is ambiguous shall be associated with the nearest possible `if` that would otherwise have no corresponding `else`.
+ It is a Syntax Error if IsLabelledFunction(|Statement|) is *true*.
+
+
+
+
It is only necessary to apply this rule if the extension specified in is implemented.
+
+
+
+
+
+
Static Semantics: ContainsDuplicateLabels
+
With argument _labelSet_.
+
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _hasDuplicate_ be ContainsDuplicateLabels of the first |Statement| with argument _labelSet_.
+ 1. If _hasDuplicate_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of the second |Statement| with argument _labelSet_.
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ 1. Return ContainsDuplicateLabels of |Statement| with argument _labelSet_.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of the first |Statement| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of the second |Statement| with argument _labelSet_.
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ 1. Return ContainsUndefinedBreakTarget of |Statement| with argument _labelSet_.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of the first |Statement| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of the second |Statement| with arguments _iterationSet_ and « ».
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ 1. Return ContainsUndefinedContinueTarget of |Statement| with arguments _iterationSet_ and « ».
+
+
+
+
+
+
Static Semantics: VarDeclaredNames
+
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _names_ be VarDeclaredNames of the first |Statement|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of the second |Statement|.
+ 1. Return _names_.
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _declarations_ be VarScopedDeclarations of the first |Statement|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of the second |Statement|.
+ 1. Return _declarations_.
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Let _exprValue_ be ToBoolean(? GetValue(_exprRef_)).
+ 1. If _exprValue_ is *true*, then
+ 1. Let _stmtCompletion_ be the result of evaluating the first |Statement|.
+ 1. Else,
+ 1. Let _stmtCompletion_ be the result of evaluating the second |Statement|.
+ 1. Return Completion(UpdateEmpty(_stmtCompletion_, *undefined*)).
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Let _exprValue_ be ToBoolean(? GetValue(_exprRef_)).
+ 1. If _exprValue_ is *false*, then
+ 1. Return NormalCompletion(*undefined*).
+ 1. Else,
+ 1. Let _stmtCompletion_ be the result of evaluating |Statement|.
+ 1. Return Completion(UpdateEmpty(_stmtCompletion_, *undefined*)).
+
+
+
+
+
+
+
The abstract operation LoopContinues with arguments _completion_ and _labelSet_ is defined by the following steps:
+
+ 1. If _completion_.[[type]] is ~normal~, return *true*.
+ 1. If _completion_.[[type]] is not ~continue~, return *false*.
+ 1. If _completion_.[[target]] is ~empty~, return *true*.
+ 1. If _completion_.[[target]] is an element of _labelSet_, return *true*.
+ 1. Return *false*.
+
+
+
Within the |Statement| part of an |IterationStatement| a |ContinueStatement| may be used to begin a new iteration.
+
+ IterationStatement : `do` Statement `while` `(` Expression `)` `;`
+
+ 1. Let _V_ be *undefined*.
+ 1. Repeat
+ 1. Let _stmt_ be the result of evaluating |Statement|.
+ 1. If LoopContinues(_stmt_, _labelSet_) is *false*, return Completion(UpdateEmpty(_stmt_, _V_)).
+ 1. If _stmt_.[[value]] is not ~empty~, let _V_ be _stmt_.[[value]].
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Let _exprValue_ be ? GetValue(_exprRef_).
+ 1. If ToBoolean(_exprValue_) is *false*, return NormalCompletion(_V_).
+
+
+
+
+
+
+
+
+ IterationStatement : `while` `(` Expression `)` Statement
+
+ 1. Let _V_ be *undefined*.
+ 1. Repeat
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Let _exprValue_ be ? GetValue(_exprRef_).
+ 1. If ToBoolean(_exprValue_) is *false*, return NormalCompletion(_V_).
+ 1. Let _stmt_ be the result of evaluating |Statement|.
+ 1. If LoopContinues(_stmt_, _labelSet_) is *false*, return Completion(UpdateEmpty(_stmt_, _V_)).
+ 1. If _stmt_.[[value]] is not ~empty~, let _V_ be _stmt_.[[value]].
+
+
+
+
+
+
+
+
+ IterationStatement : `for` `(` Expression? `;` Expression? `;` Expression? `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+ IterationStatement : `for` `(` `var` VariableDeclarationList `;` Expression? `;` Expression? `)` Statement
+
+ 1. Let _names_ be BoundNames of |VariableDeclarationList|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Statement|.
+ 1. Return _names_.
+
+ IterationStatement : `for` `(` LexicalDeclaration Expression? `;` Expression? `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ IterationStatement : `for` `(` Expression? `;` Expression? `;` Expression? `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+ IterationStatement : `for` `(` `var` VariableDeclarationList `;` Expression? `;` Expression? `)` Statement
+
+ 1. Let _declarations_ be VarScopedDeclarations of |VariableDeclarationList|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Statement|.
+ 1. Return _declarations_.
+
+ IterationStatement : `for` `(` LexicalDeclaration Expression? `;` Expression? `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+
+
+
+
+
Runtime Semantics: LabelledEvaluation
+
With argument _labelSet_.
+
+ IterationStatement : `for` `(` Expression? `;` Expression? `;` Expression? `)` Statement
+
+ 1. If the first |Expression| is present, then
+ 1. Let _exprRef_ be the result of evaluating the first |Expression|.
+ 1. Let _exprValue_ be ? GetValue(_exprRef_).
+ 1. Return ForBodyEvaluation(the second |Expression|, the third |Expression|, |Statement|, « », _labelSet_).
+
+ IterationStatement : `for` `(` `var` VariableDeclarationList `;` Expression? `;` Expression? `)` Statement
+
+ 1. Let _varDcl_ be the result of evaluating |VariableDeclarationList|.
+ 1. ReturnIfAbrupt(_varDcl_).
+ 1. Return ForBodyEvaluation(the first |Expression|, the second |Expression|, |Statement|, « », _labelSet_).
+
+ IterationStatement : `for` `(` LexicalDeclaration Expression? `;` Expression? `)` Statement
+
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _loopEnv_ be NewDeclarativeEnvironment(_oldEnv_).
+ 1. Let _isConst_ be the result of performing IsConstantDeclaration of |LexicalDeclaration|.
+ 1. Let _boundNames_ be the BoundNames of |LexicalDeclaration|.
+ 1. For each element _dn_ of _boundNames_ do
+ 1. If _isConst_ is *true*, then
+ 1. Perform _loopEnv_.CreateImmutableBinding(_dn_, *true*).
+ 1. Else,
+ 1. Perform _loopEnv_.CreateMutableBinding(_dn_, *false*).
+ 1. Assert: The above call to CreateMutableBinding will never return an abrupt completion.
+ 1. Set the running execution context's LexicalEnvironment to _loopEnv_.
+ 1. Let _forDcl_ be the result of evaluating |LexicalDeclaration|.
+ 1. If _forDcl_ is an abrupt completion, then
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return Completion(_forDcl_).
+ 1. If _isConst_ is *false*, let _perIterationLets_ be _boundNames_ otherwise let _perIterationLets_ be « ».
+ 1. Let _bodyResult_ be ForBodyEvaluation(the first |Expression|, the second |Expression|, |Statement|, _perIterationLets_, _labelSet_).
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return Completion(_bodyResult_).
+
+
+
+
+
+
The abstract operation ForBodyEvaluation with arguments _test_, _increment_, _stmt_, _perIterationBindings_, and _labelSet_ is performed as follows:
+
+ 1. Let _V_ be *undefined*.
+ 1. Let _status_ be ? CreatePerIterationEnvironment(_perIterationBindings_).
+ 1. Repeat
+ 1. If _test_ is not ~[empty]~, then
+ 1. Let _testRef_ be the result of evaluating _test_.
+ 1. Let _testValue_ be ? GetValue(_testRef_).
+ 1. If ToBoolean(_testValue_) is *false*, return NormalCompletion(_V_).
+ 1. Let _result_ be the result of evaluating _stmt_.
+ 1. If LoopContinues(_result_, _labelSet_) is *false*, return Completion(UpdateEmpty(_result_, _V_)).
+ 1. If _result_.[[value]] is not ~empty~, let _V_ be _result_.[[value]].
+ 1. Let _status_ be ? CreatePerIterationEnvironment(_perIterationBindings_).
+ 1. If _increment_ is not ~[empty]~, then
+ 1. Let _incRef_ be the result of evaluating _increment_.
+ 1. Let _incValue_ be ? GetValue(_incRef_).
+
+
+
+
+
+
The abstract operation CreatePerIterationEnvironment with argument _perIterationBindings_ is performed as follows:
+
+ 1. If _perIterationBindings_ has any elements, then
+ 1. Let _lastIterationEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _outer_ be _lastIterationEnv_'s outer environment reference.
+ 1. Assert: _outer_ is not *null*.
+ 1. Let _thisIterationEnv_ be NewDeclarativeEnvironment(_outer_).
+ 1. For each element _bn_ of _perIterationBindings_ do,
+ 1. Let _status_ be _thisIterationEnv_.CreateMutableBinding(_bn_, *false*).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Let _lastValue_ be ? _lastIterationEnv_.GetBindingValue(_bn_, *true*).
+ 1. Perform _thisIterationEnv_.InitializeBinding(_bn_, _lastValue_).
+ 1. Set the running execution context's LexicalEnvironment to _thisIterationEnv_.
+ 1. Return *undefined*.
+
+
+
+
+
+
+
+ It is a Syntax Error if |LeftHandSideExpression| is either an |ObjectLiteral| or an |ArrayLiteral| and if the lexical token sequence matched by |LeftHandSideExpression| cannot be parsed with no tokens left over using |AssignmentPattern| as the goal symbol.
+
+
+
If |LeftHandSideExpression| is either an |ObjectLiteral| or an |ArrayLiteral| and if the lexical token sequence matched by |LeftHandSideExpression| can be parsed with no tokens left over using |AssignmentPattern| as the goal symbol then the following rules are not applied. Instead, the Early Error rules for |AssignmentPattern| are used.
+
+
+ It is a Syntax Error if IsValidSimpleAssignmentTarget of |LeftHandSideExpression| is *false*.
+
+
+ It is a Syntax Error if the |LeftHandSideExpression| is CoverParenthesizedExpressionAndArrowParameterList : `(` Expression `)` and |Expression| derives a production that would produce a Syntax Error according to these rules if that production is substituted for |LeftHandSideExpression|. This rule is recursively applied.
+
+
+
+
The last rule means that the other rules are applied even if parentheses surround |Expression|.
+
+ IterationStatement : `for` `(` LeftHandSideExpression `in` Expression `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+ IterationStatement : `for` `(` `var` ForBinding `in` Expression `)` Statement
+
+ 1. Let _names_ be the BoundNames of |ForBinding|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Statement|.
+ 1. Return _names_.
+
+ IterationStatement : `for` `(` ForDeclaration `in` Expression `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+ IterationStatement : `for` `(` LeftHandSideExpression `of` AssignmentExpression `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+ IterationStatement : `for` `(` `var` ForBinding `of` AssignmentExpression `)` Statement
+
+ 1. Let _names_ be the BoundNames of |ForBinding|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Statement|.
+ 1. Return _names_.
+
+ IterationStatement : `for` `(` ForDeclaration `of` AssignmentExpression `)` Statement
+
+ 1. Return the VarDeclaredNames of |Statement|.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ IterationStatement : `for` `(` LeftHandSideExpression `in` Expression `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+ IterationStatement : `for` `(` `var` ForBinding `in` Expression `)` Statement
+
+ 1. Let _declarations_ be a List containing |ForBinding|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Statement|.
+ 1. Return _declarations_.
+
+ IterationStatement : `for` `(` ForDeclaration `in` Expression `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+ IterationStatement : `for` `(` LeftHandSideExpression `of` AssignmentExpression `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+ IterationStatement : `for` `(` `var` ForBinding `of` AssignmentExpression `)` Statement
+
+ 1. Let _declarations_ be a List containing |ForBinding|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Statement|.
+ 1. Return _declarations_.
+
+ IterationStatement : `for` `(` ForDeclaration `of` AssignmentExpression `)` Statement
+
+ 1. Return the VarScopedDeclarations of |Statement|.
+
+
+
+
+
+
Runtime Semantics: BindingInitialization
+
With arguments _value_ and _environment_.
+
+
+
*undefined* is passed for _environment_ to indicate that a PutValue operation should be used to assign the initialization value. This is the case for `var` statements and the formal parameter lists of some non-strict functions (see ). In those cases a lexical binding is hoisted and preinitialized prior to evaluation of its initializer.
+
+ ForDeclaration : LetOrConst ForBinding
+
+ 1. Return the result of performing BindingInitialization for |ForBinding| passing _value_ and _environment_ as the arguments.
+
+
+
+
+
+
Runtime Semantics: BindingInstantiation
+
With argument _environment_.
+ ForDeclaration : LetOrConst ForBinding
+
+ 1. For each element _name_ of the BoundNames of |ForBinding| do
+ 1. If IsConstantDeclaration of |LetOrConst| is *true*, then
+ 1. Perform _environment_.CreateImmutableBinding(_name_, *true*).
+ 1. Else,
+ 1. Perform _environment_.CreateMutableBinding(_name_).
+ 1. Assert: The above call to CreateMutableBinding will never return an abrupt completion.
+
+
+
+
+
+
Runtime Semantics: LabelledEvaluation
+
With argument _labelSet_.
+
+ IterationStatement : `for` `(` LeftHandSideExpression `in` Expression `)` Statement
+
+ 1. Let _keyResult_ be ? ForIn/OfHeadEvaluation( « », |Expression|, ~enumerate~).
+ 1. Return ForIn/OfBodyEvaluation(|LeftHandSideExpression|, |Statement|, _keyResult_, ~assignment~, _labelSet_).
+
+ IterationStatement : `for` `(` `var` ForBinding `in` Expression `)` Statement
+
+ 1. Let _keyResult_ be ? ForIn/OfHeadEvaluation( « », |Expression|, ~enumerate~).
+ 1. Return ForIn/OfBodyEvaluation(|ForBinding|, |Statement|, _keyResult_, ~varBinding~, _labelSet_).
+
+ IterationStatement : `for` `(` ForDeclaration `in` Expression `)` Statement
+
+ 1. Let _keyResult_ be the result of performing ? ForIn/OfHeadEvaluation(BoundNames of |ForDeclaration|, |Expression|, ~enumerate~).
+ 1. Return ForIn/OfBodyEvaluation(|ForDeclaration|, |Statement|, _keyResult_, ~lexicalBinding~, _labelSet_).
+
+ IterationStatement : `for` `(` LeftHandSideExpression `of` AssignmentExpression `)` Statement
+
+ 1. Let _keyResult_ be the result of performing ? ForIn/OfHeadEvaluation( « », |AssignmentExpression|, ~iterate~).
+ 1. Return ForIn/OfBodyEvaluation(|LeftHandSideExpression|, |Statement|, _keyResult_, ~assignment~, _labelSet_).
+
+ IterationStatement : `for` `(` `var` ForBinding `of` AssignmentExpression `)` Statement
+
+ 1. Let _keyResult_ be the result of performing ? ForIn/OfHeadEvaluation( « », |AssignmentExpression|, ~iterate~).
+ 1. Return ForIn/OfBodyEvaluation(|ForBinding|, |Statement|, _keyResult_, ~varBinding~, _labelSet_).
+
+ IterationStatement : `for` `(` ForDeclaration `of` AssignmentExpression `)` Statement
+
+ 1. Let _keyResult_ be the result of performing ? ForIn/OfHeadEvaluation( BoundNames of |ForDeclaration|, |AssignmentExpression|, ~iterate~).
+ 1. Return ForIn/OfBodyEvaluation(|ForDeclaration|, |Statement|, _keyResult_, ~lexicalBinding~, _labelSet_).
+
+
+
+
+
+
The abstract operation ForIn/OfHeadEvaluation is called with arguments _TDZnames_, _expr_, and _iterationKind_. The value of _iterationKind_ is either ~enumerate~ or ~iterate~.
+
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. If _TDZnames_ is not an empty List, then
+ 1. Assert: _TDZnames_ has no duplicate entries.
+ 1. Let _TDZ_ be NewDeclarativeEnvironment(_oldEnv_).
+ 1. For each string _name_ in _TDZnames_, do
+ 1. Let _status_ be _TDZ_.CreateMutableBinding(_name_, *false*).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Set the running execution context's LexicalEnvironment to _TDZ_.
+ 1. Let _exprRef_ be the result of evaluating the production that is _expr_.
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Let _exprValue_ be ? GetValue(_exprRef_).
+ 1. If _iterationKind_ is ~enumerate~, then
+ 1. If _exprValue_.[[value]] is *null* or *undefined*, then
+ 1. Return Completion{[[type]]: ~break~, [[value]]: ~empty~, [[target]]: ~empty~}.
+ 1. Let _obj_ be ToObject(_exprValue_).
+ 1. Return _obj_.[[Enumerate]]().
+ 1. Else,
+ 1. Assert: _iterationKind_ is ~iterate~.
+ 1. Return GetIterator(_exprValue_).
+
+
+
+
+
+
The abstract operation ForIn/OfBodyEvaluation is called with arguments _lhs_, _stmt_, _iterator_, _lhsKind_, and _labelSet_. The value of _lhsKind_ is either ~assignment~, ~varBinding~ or ~lexicalBinding~.
+
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _V_ be *undefined*.
+ 1. Let _destructuring_ be IsDestructuring of _lhs_.
+ 1. If _destructuring_ is *true* and if _lhsKind_ is ~assignment~, then
+ 1. Assert: _lhs_ is a |LeftHandSideExpression|.
+ 1. Let _assignmentPattern_ be the parse of the source text corresponding to _lhs_ using |AssignmentPattern| as the goal symbol.
+ 1. Repeat
+ 1. Let _nextResult_ be ? IteratorStep(_iterator_).
+ 1. If _nextResult_ is *false*, return NormalCompletion(_V_).
+ 1. Let _nextValue_ be ? IteratorValue(_nextResult_).
+ 1. If _lhsKind_ is either ~assignment~ or ~varBinding~, then
+ 1. If _destructuring_ is *false*, then
+ 1. Let _lhsRef_ be the result of evaluating _lhs_ ( it may be evaluated repeatedly).
+ 1. Else,
+ 1. Assert: _lhsKind_ is ~lexicalBinding~.
+ 1. Assert: _lhs_ is a |ForDeclaration|.
+ 1. Let _iterationEnv_ be NewDeclarativeEnvironment(_oldEnv_).
+ 1. Perform BindingInstantiation for _lhs_ passing _iterationEnv_ as the argument.
+ 1. Set the running execution context's LexicalEnvironment to _iterationEnv_.
+ 1. If _destructuring_ is *false*, then
+ 1. Assert: _lhs_ binds a single name.
+ 1. Let _lhsName_ be the sole element of BoundNames of _lhs_.
+ 1. Let _lhsRef_ be ResolveBinding(_lhsName_).
+ 1. Assert: _lhsRef_ is not an abrupt completion.
+ 1. If _destructuring_ is *false*, then
+ 1. If _lhsRef_ is an abrupt completion, then
+ 1. Let _status_ be _lhsRef_.
+ 1. Else if _lhsKind_ is ~lexicalBinding~, then
+ 1. Let _status_ be InitializeReferencedBinding(_lhsRef_, _nextValue_).
+ 1. Else,
+ 1. Let _status_ be PutValue(_lhsRef_, _nextValue_).
+ 1. Else,
+ 1. If _lhsKind_ is ~assignment~, then
+ 1. Let _status_ be the result of performing DestructuringAssignmentEvaluation of _assignmentPattern_ using _nextValue_ as the argument.
+ 1. Else if _lhsKind_ is ~varBinding~, then
+ 1. Assert: _lhs_ is a |ForBinding|.
+ 1. Let _status_ be the result of performing BindingInitialization for _lhs_ passing _nextValue_ and *undefined* as the arguments.
+ 1. Else,
+ 1. Assert: _lhsKind_ is ~lexicalBinding~.
+ 1. Assert: _lhs_ is a |ForDeclaration|.
+ 1. Let _status_ be the result of performing BindingInitialization for _lhs_ passing _nextValue_ and _iterationEnv_ as arguments.
+ 1. If _status_ is an abrupt completion, then
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return IteratorClose(_iterator_, _status_).
+ 1. Let _result_ be the result of evaluating _stmt_.
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. If LoopContinues(_result_, _labelSet_) is *false*, return IteratorClose(_iterator_, UpdateEmpty(_result_, _V_)).
+ 1. If _result_.[[value]] is not ~empty~, let _V_ be _result_.[[value]].
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ ForBinding : BindingIdentifier
+
+ 1. Let _bindingId_ be StringValue of |BindingIdentifier|.
+ 1. Return ResolveBinding(_bindingId_).
+
+
+
+
+
+
+
+
+ It is a Syntax Error if this production is not nested, directly or indirectly (but not crossing function boundaries), within an |IterationStatement|.
+
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ ContinueStatement : `continue` `;`
+
+ 1. Return *false*.
+
+ ContinueStatement : `continue` LabelIdentifier `;`
+
+ 1. If the StringValue of |LabelIdentifier| is not an element of _iterationSet_, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
+ It is a Syntax Error if this production is not nested, directly or indirectly (but not crossing function boundaries), within an |IterationStatement| or a |SwitchStatement|.
+
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ BreakStatement : `break` `;`
+
+ 1. Return *false*.
+
+ BreakStatement : `break` LabelIdentifier `;`
+
+ 1. If the StringValue of |LabelIdentifier| is not an element of _labelSet_, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
A `return` statement causes a function to cease execution and return a value to the caller. If |Expression| is omitted, the return value is *undefined*. Otherwise, the return value is the value of |Expression|.
+
+
+
+
+
Runtime Semantics: Evaluation
+ ReturnStatement : `return` `;`
+
+ 1. Return Completion{[[type]]: ~return~, [[value]]: *undefined*, [[target]]: ~empty~}.
+
+ ReturnStatement : `return` Expression `;`
+
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Let _exprValue_ be ? GetValue(_exprRef_).
+ 1. Return Completion{[[type]]: ~return~, [[value]]: _exprValue_, [[target]]: ~empty~}.
+
+
+
+
+
+
+
The `with` statement adds an object Environment Record for a computed object to the lexical environment of the running execution context. It then executes a statement using this augmented lexical environment. Finally, it restores the original lexical environment.
+ WithStatement : `with` `(` Expression `)` Statement
+
+ 1. Let _val_ be the result of evaluating |Expression|.
+ 1. Let _obj_ be ? ToObject(? GetValue(_val_)).
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _newEnv_ be NewObjectEnvironment(_obj_, _oldEnv_).
+ 1. Set the _withEnvironment_ flag of _newEnv_'s EnvironmentRecord to *true*.
+ 1. Set the running execution context's LexicalEnvironment to _newEnv_.
+ 1. Let _C_ be the result of evaluating |Statement|.
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return Completion(UpdateEmpty(_C_, *undefined*)).
+
+
+
No matter how control leaves the embedded |Statement|, whether normally or by some form of abrupt completion or exception, the LexicalEnvironment is always restored to its former state.
+ It is a Syntax Error if the LexicallyDeclaredNames of |CaseClauses| contains any duplicate entries.
+
+
+ It is a Syntax Error if any element of the LexicallyDeclaredNames of |CaseClauses| also occurs in the VarDeclaredNames of |CaseClauses|.
+
+
+
+
+
+
+
Static Semantics: ContainsDuplicateLabels
+
With argument _labelSet_.
+
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Return ContainsDuplicateLabels of |CaseBlock| with argument _labelSet_.
+
+ CaseBlock : `{` `}`
+
+ 1. Return *false*.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, then
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of the first |CaseClauses| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |DefaultClause| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. If the second |CaseClauses| is not present, return *false*.
+ 1. Return ContainsDuplicateLabels of the second |CaseClauses| with argument _labelSet_.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |CaseClauses| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of |CaseClause| with argument _labelSet_.
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return ContainsDuplicateLabels of |StatementList| with argument _labelSet_.
+ 1. Else return *false*.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return ContainsDuplicateLabels of |StatementList| with argument _labelSet_.
+ 1. Else return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Return ContainsUndefinedBreakTarget of |CaseBlock| with argument _labelSet_.
+
+ CaseBlock : `{` `}`
+
+ 1. Return *false*.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, then
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of the first |CaseClauses| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |DefaultClause| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. If the second |CaseClauses| is not present, return *false*.
+ 1. Return ContainsUndefinedBreakTarget of the second |CaseClauses| with argument _labelSet_.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |CaseClauses| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of |CaseClause| with argument _labelSet_.
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return ContainsUndefinedBreakTarget of |StatementList| with argument _labelSet_.
+ 1. Else return *false*.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return ContainsUndefinedBreakTarget of |StatementList| with argument _labelSet_.
+ 1. Else return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Return ContainsUndefinedContinueTarget of |CaseBlock| with arguments _iterationSet_ and « ».
+
+ CaseBlock : `{` `}`
+
+ 1. Return *false*.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, then
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of the first |CaseClauses| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |DefaultClause| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. If the second |CaseClauses| is not present, return *false*.
+ 1. Return ContainsUndefinedContinueTarget of the second |CaseClauses| with arguments _iterationSet_ and « ».
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |CaseClauses| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of |CaseClause| with arguments _iterationSet_ and « ».
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return ContainsUndefinedContinueTarget of |StatementList| with arguments _iterationSet_ and « ».
+ 1. Else return *false*.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return ContainsUndefinedContinueTarget of |StatementList| with arguments _iterationSet_ and « ».
+ 1. Else return *false*.
+
+
+
+
+
+
Static Semantics: LexicallyDeclaredNames
+
+ CaseBlock : `{` `}`
+
+ 1. Return a new empty List.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, let _names_ be the LexicallyDeclaredNames of the first |CaseClauses|.
+ 1. Else let _names_ be a new empty List.
+ 1. Append to _names_ the elements of the LexicallyDeclaredNames of the |DefaultClause|.
+ 1. If the second |CaseClauses| is not present, return _names_.
+ 1. Else return the result of appending to _names_ the elements of the LexicallyDeclaredNames of the second |CaseClauses|.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _names_ be LexicallyDeclaredNames of |CaseClauses|.
+ 1. Append to _names_ the elements of the LexicallyDeclaredNames of |CaseClause|.
+ 1. Return _names_.
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return the LexicallyDeclaredNames of |StatementList|.
+ 1. Else return a new empty List.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return the LexicallyDeclaredNames of |StatementList|.
+ 1. Else return a new empty List.
+
+
+
+
+
+
Static Semantics: LexicallyScopedDeclarations
+
+ CaseBlock : `{` `}`
+
+ 1. Return a new empty List.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, let _declarations_ be the LexicallyScopedDeclarations of the first |CaseClauses|.
+ 1. Else let _declarations_ be a new empty List.
+ 1. Append to _declarations_ the elements of the LexicallyScopedDeclarations of the |DefaultClause|.
+ 1. If the second |CaseClauses| is not present, return _declarations_.
+ 1. Else return the result of appending to _declarations_ the elements of the LexicallyScopedDeclarations of the second |CaseClauses|.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _declarations_ be LexicallyScopedDeclarations of |CaseClauses|.
+ 1. Append to _declarations_ the elements of the LexicallyScopedDeclarations of |CaseClause|.
+ 1. Return _declarations_.
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return the LexicallyScopedDeclarations of |StatementList|.
+ 1. Else return a new empty List.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return the LexicallyScopedDeclarations of |StatementList|.
+ 1. Else return a new empty List.
+
+
+
+
+
+
Static Semantics: VarDeclaredNames
+
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Return the VarDeclaredNames of |CaseBlock|.
+
+ CaseBlock : `{` `}`
+
+ 1. Return a new empty List.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, let _names_ be the VarDeclaredNames of the first |CaseClauses|.
+ 1. Else let _names_ be a new empty List.
+ 1. Append to _names_ the elements of the VarDeclaredNames of the |DefaultClause|.
+ 1. If the second |CaseClauses| is not present, return _names_.
+ 1. Else return the result of appending to _names_ the elements of the VarDeclaredNames of the second |CaseClauses|.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _names_ be VarDeclaredNames of |CaseClauses|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |CaseClause|.
+ 1. Return _names_.
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return the VarDeclaredNames of |StatementList|.
+ 1. Else return a new empty List.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return the VarDeclaredNames of |StatementList|.
+ 1. Else return a new empty List.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Return the VarScopedDeclarations of |CaseBlock|.
+
+ CaseBlock : `{` `}`
+
+ 1. Return a new empty List.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. If the first |CaseClauses| is present, let _declarations_ be the VarScopedDeclarations of the first |CaseClauses|.
+ 1. Else let _declarations_ be a new empty List.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of the |DefaultClause|.
+ 1. If the second |CaseClauses| is not present, return _declarations_.
+ 1. Else return the result of appending to _declarations_ the elements of the VarScopedDeclarations of the second |CaseClauses|.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _declarations_ be VarScopedDeclarations of |CaseClauses|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |CaseClause|.
+ 1. Return _declarations_.
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. If the |StatementList| is present, return the VarScopedDeclarations of |StatementList|.
+ 1. Else return a new empty List.
+
+ DefaultClause : `default` `:` StatementList?
+
+ 1. If the |StatementList| is present, return the VarScopedDeclarations of |StatementList|.
+ 1. Else return a new empty List.
+
+
+
+
+
+
Runtime Semantics: CaseBlockEvaluation
+
With argument _input_.
+ CaseBlock : `{` `}`
+
+ 1. Return NormalCompletion(*undefined*).
+
+ CaseBlock : `{` CaseClauses `}`
+
+ 1. Let _V_ be *undefined*.
+ 1. Let _A_ be the List of |CaseClause| items in |CaseClauses|, in source text order.
+ 1. Let _found_ be *false*.
+ 1. Repeat for each |CaseClause| _C_ in _A_,
+ 1. If _found_ is *false*, then
+ 1. Let _clauseSelector_ be the result of CaseSelectorEvaluation of _C_.
+ 1. ReturnIfAbrupt(_clauseSelector_).
+ 1. Let _found_ be the result of performing Strict Equality Comparison _input_ === _clauseSelector_.[[value]].
+ 1. If _found_ is *true*, then
+ 1. Let _R_ be the result of evaluating _C_.
+ 1. If _R_.[[value]] is not ~empty~, let _V_ be _R_.[[value]].
+ 1. If _R_ is an abrupt completion, return Completion(UpdateEmpty(_R_, _V_)).
+ 1. Return NormalCompletion(_V_).
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. Let _V_ be *undefined*.
+ 1. Let _A_ be the list of |CaseClause| items in the first |CaseClauses|, in source text order. If the first |CaseClauses| is not present _A_ is « ».
+ 1. Let _found_ be *false*.
+ 1. Repeat for each |CaseClause| _C_ in _A_
+ 1. If _found_ is *false*, then
+ 1. Let _clauseSelector_ be the result of CaseSelectorEvaluation of _C_.
+ 1. ReturnIfAbrupt(_clauseSelector_).
+ 1. Let _found_ be the result of performing Strict Equality Comparison _input_ === _clauseSelector_.[[value]].
+ 1. If _found_ is *true*, then
+ 1. Let _R_ be the result of evaluating _C_.
+ 1. If _R_.[[value]] is not ~empty~, let _V_ be _R_.[[value]].
+ 1. If _R_ is an abrupt completion, return Completion(UpdateEmpty(_R_, _V_)).
+ 1. Let _foundInB_ be *false*.
+ 1. Let _B_ be the List containing the |CaseClause| items in the second |CaseClauses|, in source text order. If the second |CaseClauses| is not present _B_ is « ».
+ 1. If _found_ is *false*, then
+ 1. Repeat for each |CaseClause| _C_ in _B_
+ 1. If _foundInB_ is *false*, then
+ 1. Let _clauseSelector_ be the result of CaseSelectorEvaluation of _C_.
+ 1. ReturnIfAbrupt(_clauseSelector_).
+ 1. Let _foundInB_ be the result of performing Strict Equality Comparison _input_ === _clauseSelector_.[[value]].
+ 1. If _foundInB_ is *true*, then
+ 1. Let _R_ be the result of evaluating |CaseClause| _C_.
+ 1. If _R_.[[value]] is not ~empty~, let _V_ be _R_.[[value]].
+ 1. If _R_ is an abrupt completion, return Completion(UpdateEmpty(_R_, _V_)).
+ 1. If _foundInB_ is *true*, return NormalCompletion(_V_).
+ 1. Let _R_ be the result of evaluating |DefaultClause|.
+ 1. If _R_.[[value]] is not ~empty~, let _V_ be _R_.[[value]].
+ 1. If _R_ is an abrupt completion, return Completion(UpdateEmpty(_R_, _V_)).
+ 1. Repeat for each |CaseClause| _C_ in _B_ (NOTE this is another complete iteration of the second |CaseClauses|)
+ 1. Let _R_ be the result of evaluating |CaseClause| _C_.
+ 1. If _R_.[[value]] is not ~empty~, let _V_ be _R_.[[value]].
+ 1. If _R_ is an abrupt completion, return Completion(UpdateEmpty(_R_, _V_)).
+ 1. Return NormalCompletion(_V_).
+
+
+
+
+
+
Runtime Semantics: CaseSelectorEvaluation
+ CaseClause : `case` Expression `:` StatementList?
+
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Return GetValue(_exprRef_).
+
+
+
CaseSelectorEvaluation does not execute the associated |StatementList|. It simply evaluates the |Expression| and returns the value, which the |CaseBlock| algorithm uses to determine which |StatementList| to start executing.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Let _exprRef_ be the result of evaluating |Expression|.
+ 1. Let _switchValue_ be ? GetValue(_exprRef_).
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _blockEnv_ be NewDeclarativeEnvironment(_oldEnv_).
+ 1. Perform BlockDeclarationInstantiation(|CaseBlock|, _blockEnv_).
+ 1. Set the running execution context's LexicalEnvironment to _blockEnv_.
+ 1. Let _R_ be the result of performing CaseBlockEvaluation of |CaseBlock| with argument _switchValue_.
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return _R_.
+
+
+
No matter how control leaves the |SwitchStatement| the LexicalEnvironment is always restored to its former state.
A |Statement| may be prefixed by a label. Labelled statements are only used in conjunction with labelled `break` and `continue` statements. ECMAScript has no `goto` statement. A |Statement| can be part of a |LabelledStatement|, which itself can be part of a |LabelledStatement|, and so on. The labels introduced this way are collectively referred to as the “current label set” when describing the semantics of individual statements.
+
+
+
+
+
Static Semantics: Early Errors
+ LabelledItem : FunctionDeclaration
+
+
+ It is a Syntax Error if any source text matches this rule.
+
+
+
+
An alternative definition for this rule is provided in .
+
+
+
+
+
+
Static Semantics: ContainsDuplicateLabels
+
With argument _labelSet_.
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Let _label_ be the StringValue of |LabelIdentifier|.
+ 1. If _label_ is an element of _labelSet_, return *true*.
+ 1. Let _newLabelSet_ be a copy of _labelSet_ with _label_ appended.
+ 1. Return ContainsDuplicateLabels of |LabelledItem| with argument _newLabelSet_.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Let _label_ be the StringValue of |LabelIdentifier|.
+ 1. Let _newLabelSet_ be a copy of _labelSet_ with _label_ appended.
+ 1. Return ContainsUndefinedBreakTarget of |LabelledItem| with argument _newLabelSet_.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Let _label_ be the StringValue of |LabelIdentifier|.
+ 1. Let _newLabelSet_ be a copy of _labelSet_ with _label_ appended.
+ 1. Return ContainsUndefinedContinueTarget of |LabelledItem| with arguments _iterationSet_ and _newLabelSet_.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: IsLabelledFunction ( _stmt_ )
+
The abstract operation IsLabelledFunction with argument _stmt_ performs the following steps:
+
+ 1. If _stmt_ is not a |LabelledStatement|, return *false*.
+ 1. Let _item_ be the |LabelledItem| component of _stmt_.
+ 1. If _item_ is LabelledItem : FunctionDeclaration , return *true*.
+ 1. Let _subStmt_ be the |Statement| component of _item_.
+ 1. Return IsLabelledFunction(_subStmt_).
+
+
+
+
+
+
Static Semantics: LexicallyDeclaredNames
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Return the LexicallyDeclaredNames of |LabelledItem|.
+
+ LabelledItem : Statement
+
+ 1. Return a new empty List.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return BoundNames of |FunctionDeclaration|.
+
+
+
+
+
+
Static Semantics: LexicallyScopedDeclarations
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Return the LexicallyScopedDeclarations of |LabelledItem|.
+
+ LabelledItem : Statement
+
+ 1. Return a new empty List.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return a new List containing |FunctionDeclaration|.
+
+
+
+
+
+
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Return the TopLevelVarDeclaredNames of |LabelledItem|.
+
+ LabelledItem : Statement
+
+ 1. If |Statement| is Statement : LabelledStatement , return TopLevelVarDeclaredNames of |Statement|.
+ 1. Return VarDeclaredNames of |Statement|.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return BoundNames of |FunctionDeclaration|.
+
+
+
+
+
+
Static Semantics: TopLevelVarScopedDeclarations
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Return the TopLevelVarScopedDeclarations of |LabelledItem|.
+
+ LabelledItem : Statement
+
+ 1. If |Statement| is Statement : LabelledStatement , return TopLevelVarScopedDeclarations of |Statement|.
+ 1. Return VarScopedDeclarations of |Statement|.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return a new List containing |FunctionDeclaration|.
+
+
+
+
+
+
Static Semantics: VarDeclaredNames
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Return the VarDeclaredNames of |LabelledItem|.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Return the VarScopedDeclarations of |LabelledItem|.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Runtime Semantics: LabelledEvaluation
+
With argument _labelSet_.
+
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Let _label_ be the StringValue of |LabelIdentifier|.
+ 1. Append _label_ as an element of _labelSet_.
+ 1. Let _stmtResult_ be LabelledEvaluation of |LabelledItem| with argument _labelSet_.
+ 1. If _stmtResult_.[[type]] is ~break~ and SameValue(_stmtResult_.[[target]], _label_), then
+ 1. Let _stmtResult_ be NormalCompletion(_stmtResult_.[[value]]).
+ 1. Return Completion(_stmtResult_).
+
+ LabelledItem : Statement
+
+ 1. If |Statement| is either a |LabelledStatement| or a |BreakableStatement|, then
+ 1. Return LabelledEvaluation of |Statement| with argument _labelSet_.
+ 1. Else,
+ 1. Return the result of evaluating |Statement|.
+
+ LabelledItem : FunctionDeclaration
+
+ 1. Return the result of evaluating |FunctionDeclaration|.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ LabelledStatement : LabelIdentifier `:` LabelledItem
+
+ 1. Let _newLabelSet_ be a new empty List.
+ 1. Return LabelledEvaluation of |LabelledItem| with argument _newLabelSet_.
+
+
+
+
+
+
+
The `try` statement encloses a block of code in which an exceptional condition can occur, such as a runtime error or a `throw` statement. The `catch` clause provides the exception-handling code. When a catch clause catches an exception, its |CatchParameter| is bound to that exception.
+
+
+
+
+
Static Semantics: Early Errors
+ Catch : `catch` `(` CatchParameter `)` Block
+
+
+ It is a Syntax Error if BoundNames of |CatchParameter| contains any duplicate elements.
+
+
+ It is a Syntax Error if any element of the BoundNames of |CatchParameter| also occurs in the LexicallyDeclaredNames of |Block|.
+
+
+ It is a Syntax Error if any element of the BoundNames of |CatchParameter| also occurs in the VarDeclaredNames of |Block|.
+
+
+
+
An alternative static semantics for this production is given in .
+
+
+
+
+
+
Static Semantics: ContainsDuplicateLabels
+
With argument _labelSet_.
+
+ TryStatement : `try` Block Catch
+
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |Block| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of |Catch| with argument _labelSet_.
+
+ TryStatement : `try` Block Finally
+
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |Block| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of |Finally| with argument _labelSet_.
+
+ TryStatement : `try` Block Catch Finally
+
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |Block| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |Catch| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of |Finally| with argument _labelSet_.
+
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Return ContainsDuplicateLabels of |Block| with argument _labelSet_.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ TryStatement : `try` Block Catch
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |Block| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of |Catch| with argument _labelSet_.
+
+ TryStatement : `try` Block Finally
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |Block| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of |Finally| with argument _labelSet_.
+
+ TryStatement : `try` Block Catch Finally
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |Block| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |Catch| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of |Finally| with argument _labelSet_.
+
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Return ContainsUndefinedBreakTarget of |Block| with argument _labelSet_.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ TryStatement : `try` Block Catch
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |Block| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of |Catch| with arguments _iterationSet_ and « ».
+
+ TryStatement : `try` Block Finally
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |Block| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of |Finally| with arguments _iterationSet_ and « ».
+
+ TryStatement : `try` Block Catch Finally
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |Block| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |Catch| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of |Finally| with arguments _iterationSet_ and « ».
+
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Return ContainsUndefinedContinueTarget of |Block| with arguments _iterationSet_ and « ».
+
+
+
+
+
+
Static Semantics: VarDeclaredNames
+
+ TryStatement : `try` Block Catch
+
+ 1. Let _names_ be VarDeclaredNames of |Block|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Catch|.
+ 1. Return _names_.
+
+ TryStatement : `try` Block Finally
+
+ 1. Let _names_ be VarDeclaredNames of |Block|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Finally|.
+ 1. Return _names_.
+
+ TryStatement : `try` Block Catch Finally
+
+ 1. Let _names_ be VarDeclaredNames of |Block|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Catch|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |Finally|.
+ 1. Return _names_.
+
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Return the VarDeclaredNames of |Block|.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ TryStatement : `try` Block Catch
+
+ 1. Let _declarations_ be VarScopedDeclarations of |Block|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Catch|.
+ 1. Return _declarations_.
+
+ TryStatement : `try` Block Finally
+
+ 1. Let _declarations_ be VarScopedDeclarations of |Block|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Finally|.
+ 1. Return _declarations_.
+
+ TryStatement : `try` Block Catch Finally
+
+ 1. Let _declarations_ be VarScopedDeclarations of |Block|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Catch|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |Finally|.
+ 1. Return _declarations_.
+
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Return the VarScopedDeclarations of |Block|.
+
+
+
+
+
+
Runtime Semantics: CatchClauseEvaluation
+
with parameter _thrownValue_
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Let _oldEnv_ be the running execution context's LexicalEnvironment.
+ 1. Let _catchEnv_ be NewDeclarativeEnvironment(_oldEnv_).
+ 1. For each element _argName_ of the BoundNames of |CatchParameter|, do
+ 1. Perform _catchEnv_.CreateMutableBinding(_argName_).
+ 1. Assert: The above call to CreateMutableBinding will never return an abrupt completion.
+ 1. Set the running execution context's LexicalEnvironment to _catchEnv_.
+ 1. Let _status_ be the result of performing BindingInitialization for |CatchParameter| passing _thrownValue_ and _catchEnv_ as arguments.
+ 1. If _status_ is an abrupt completion, then
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return Completion(_status_).
+ 1. Let _B_ be the result of evaluating |Block|.
+ 1. Set the running execution context's LexicalEnvironment to _oldEnv_.
+ 1. Return Completion(_B_).
+
+
+
No matter how control leaves the |Block| the LexicalEnvironment is always restored to its former state.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ TryStatement : `try` Block Catch
+
+ 1. Let _B_ be the result of evaluating |Block|.
+ 1. If _B_.[[type]] is ~throw~, let _C_ be CatchClauseEvaluation of |Catch| with parameter _B_.[[value]].
+ 1. Else, let _C_ be _B_.
+ 1. Return Completion(UpdateEmpty(_C_, *undefined*)).
+
+ TryStatement : `try` Block Finally
+
+ 1. Let _B_ be the result of evaluating |Block|.
+ 1. Let _F_ be the result of evaluating |Finally|.
+ 1. If _F_.[[type]] is ~normal~, let _F_ be _B_.
+ 1. Return Completion(UpdateEmpty(_F_, *undefined*)).
+
+ TryStatement : `try` Block Catch Finally
+
+ 1. Let _B_ be the result of evaluating |Block|.
+ 1. If _B_.[[type]] is ~throw~, let _C_ be CatchClauseEvaluation of |Catch| with parameter _B_.[[value]].
+ 1. Else, let _C_ be _B_.
+ 1. Let _F_ be the result of evaluating |Finally|.
+ 1. If _F_.[[type]] is ~normal~, let _F_ be _C_.
+ 1. Return Completion(UpdateEmpty(_F_, *undefined*)).
+
+
+
+
+
+
+
Evaluating the |DebuggerStatement| production may allow an implementation to cause a breakpoint when run under a debugger. If a debugger is not present or active this statement has no observable effect.
+
+ DebuggerStatement : `debugger` `;`
+
+ 1. If an implementation defined debugging facility is available and enabled, then
+ 1. Perform an implementation defined debugging action.
+ 1. Let _result_ be an implementation defined Completion value.
+ 1. Else,
+ 1. Let _result_ be NormalCompletion(~empty~).
+ 1. Return _result_.
+
+
+
+
+
+
+
+
ECMAScript Language: Functions and Classes
+
+
Various ECMAScript language elements cause the creation of ECMAScript function objects (). Evaluation of such functions starts with the execution of their [[Call]] internal method ().
A Directive Prologue is the longest sequence of |ExpressionStatement| productions occurring as the initial |StatementListItem| or |ModuleItem| productions of a |FunctionBody|, a |ScriptBody|, or a |ModuleBody| and where each |ExpressionStatement| in the sequence consists entirely of a |StringLiteral| token followed by a semicolon. The semicolon may appear explicitly or may be inserted by automatic semicolon insertion. A Directive Prologue may be an empty sequence.
+
A Use Strict Directive is an |ExpressionStatement| in a Directive Prologue whose |StringLiteral| is either the exact code unit sequences `"use strict"` or `'use strict'`. A Use Strict Directive may not contain an |EscapeSequence| or |LineContinuation|.
+
A Directive Prologue may contain more than one Use Strict Directive. However, an implementation may issue a warning if this occurs.
+
+
The |ExpressionStatement| productions of a Directive Prologue are evaluated normally during evaluation of the containing production. Implementations may define implementation specific meanings for |ExpressionStatement| productions which are not a Use Strict Directive and which occur in a Directive Prologue. If an appropriate notification mechanism exists, an implementation should issue a warning if it encounters in a Directive Prologue an |ExpressionStatement| that is not a Use Strict Directive and which does not have a meaning defined by the implementation.
+ If the source code matching this production is strict code, the Early Error rules for StrictFormalParameters : FormalParameters are applied.
+
+
+ If the source code matching this production is strict code, it is a Syntax Error if |BindingIdentifier| is the |IdentifierName| `eval` or the |IdentifierName| `arguments`.
+
+
+ It is a Syntax Error if ContainsUseStrict of |FunctionBody| is *true* and IsSimpleParameterList of |FormalParameters| is *false*.
+
+
+ It is a Syntax Error if any element of the BoundNames of |FormalParameters| also occurs in the LexicallyDeclaredNames of |FunctionBody|.
+
+
+ It is a Syntax Error if |FormalParameters| Contains |SuperProperty| is *true*.
+
+
+ It is a Syntax Error if |FunctionBody| Contains |SuperProperty| is *true*.
+
+
+ It is a Syntax Error if |FormalParameters| Contains |SuperCall| is *true*.
+
+
+ It is a Syntax Error if |FunctionBody| Contains |SuperCall| is *true*.
+
+
+
+
The LexicallyDeclaredNames of a |FunctionBody| does not include identifiers bound using var or function declarations.
+
+ StrictFormalParameters : FormalParameters
+
+
+ It is a Syntax Error if BoundNames of |FormalParameters| contains any duplicate elements.
+
+
+ FormalParameters : FormalParameterList
+
+
+ It is a Syntax Error if IsSimpleParameterList of |FormalParameterList| is *false* and BoundNames of |FormalParameterList| contains any duplicate elements.
+
+
+
+
Multiple occurrences of the same |BindingIdentifier| in a |FormalParameterList| is only allowed for functions and generator functions which have simple parameter lists and which are not defined in strict mode code.
+
+ FunctionBody : FunctionStatementList
+
+
+ It is a Syntax Error if the LexicallyDeclaredNames of |FunctionStatementList| contains any duplicate entries.
+
+
+ It is a Syntax Error if any element of the LexicallyDeclaredNames of |FunctionStatementList| also occurs in the VarDeclaredNames of |FunctionStatementList|.
+
+
+ It is a Syntax Error if ContainsDuplicateLabels of |FunctionStatementList| with argument « » is *true*.
+
+
+ It is a Syntax Error if ContainsUndefinedBreakTarget of |FunctionStatementList| with argument « » is *true*.
+
+
+ It is a Syntax Error if ContainsUndefinedContinueTarget of |FunctionStatementList| with arguments « » and « » is *true*.
+
The ExpectedArgumentCount of a |FormalParameterList| is the number of |FormalParameters| to the left of either the rest parameter or the first |FormalParameter| with an Initializer. A |FormalParameter| without an initializer is allowed after the first parameter with an initializer but such parameters are considered to be optional with *undefined* as their default value.
+
+ FormalsList : FormalParameter
+
+ 1. If HasInitializer of |FormalParameter| is *true*, return 0.
+ 1. Return 1.
+
+ FormalsList : FormalsList `,` FormalParameter
+
+ 1. Let _count_ be the ExpectedArgumentCount of |FormalsList|.
+ 1. If HasInitializer of |FormalsList| is *true* or HasInitializer of |FormalParameter| is *true*, return _count_.
+ 1. Return _count_+1.
+
+
+
+
+
+
Static Semantics: HasInitializer
+
+ FormalsList : FormalsList `,` FormalParameter
+
+ 1. If HasInitializer of |FormalsList| is *true*, return *true*.
+ 1. Return HasInitializer of |FormalParameter|.
+
+
+
+
+
+
The abstract operation IsAnonymousFunctionDefinition determines if its argument is a function definition that does not bind a name. The argument _production_ is the result of parsing an |AssignmentExpression| or |Initializer|. The following steps are taken:
+
+ 1. If IsFunctionDefinition of _production_ is *false*, return *false*.
+ 1. Let _hasName_ be the result of HasName of _production_.
+ 1. If _hasName_ is *true*, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
+
+ FunctionBody : FunctionStatementList
+
+ 1. Return the result of evaluating |FunctionStatementList|.
+
+
+
+
+
+
Runtime Semantics: IteratorBindingInitialization
+
With parameters _iteratorRecord_ and _environment_.
+
+
When *undefined* is passed for _environment_ it indicates that a PutValue operation should be used to assign the initialization value. This is the case for formal parameter lists of non-strict functions. In that case the formal parameter bindings are preinitialized in order to deal with the possibility of multiple parameters with the same name.
+
+
+ FormalParameters : [empty]
+
+ 1. Return NormalCompletion(~empty~).
+
+ FormalParameterList : FormalsList `,` FunctionRestParameter
+
+ 1. Let _restIndex_ be the result of performing IteratorBindingInitialization for |FormalsList| using _iteratorRecord_, and _environment_ as the arguments.
+ 1. ReturnIfAbrupt(_restIndex_).
+ 1. Return the result of performing IteratorBindingInitialization for |FunctionRestParameter| using _iteratorRecord_ and _environment_ as the arguments.
+
+ FormalsList : FormalsList `,` FormalParameter
+
+ 1. Let _status_ be the result of performing IteratorBindingInitialization for |FormalsList| using _iteratorRecord_ and _environment_ as the arguments.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return the result of performing IteratorBindingInitialization for |FormalParameter| using _iteratorRecord_ and _environment_ as the arguments.
+
+ FormalParameter : BindingElement
+
+ 1. If ContainsExpression of |BindingElement| is *false*, return the result of performing IteratorBindingInitialization for |BindingElement| using _iteratorRecord_ and _environment_ as the arguments.
+ 1. Let _currentContext_ be the running execution context.
+ 1. Let _originalEnv_ be the VariableEnvironment of _currentContext_.
+ 1. Assert: The VariableEnvironment and LexicalEnvironment of _currentContext_ are the same.
+ 1. Assert: _environment_ and _originalEnv_ are the same.
+ 1. Let _paramVarEnv_ be NewDeclarativeEnvironment(_originalEnv_).
+ 1. Set the VariableEnvironment of _currentContext_ to _paramVarEnv_.
+ 1. Set the LexicalEnvironment of _currentContext_ to _paramVarEnv_.
+ 1. Let _result_ be the result of performing IteratorBindingInitialization for |BindingElement| using _iteratorRecord_ and _environment_ as the arguments.
+ 1. Set the VariableEnvironment of _currentContext_ to _originalEnv_.
+ 1. Set the LexicalEnvironment of _currentContext_ to _originalEnv_.
+ 1. Return _result_.
+
+
+
The new Environment Record created in step 6 is only used if the |BindingElement| contains a direct eval.
+
+ FunctionRestParameter : BindingRestElement
+
+ 1. If ContainsExpression of |BindingRestElement| is *false*, return the result of performing IteratorBindingInitialization for |BindingRestElement| using _iteratorRecord_ and _environment_ as the arguments.
+ 1. Let _currentContext_ be the running execution context.
+ 1. Let _originalEnv_ be the VariableEnvironment of _currentContext_.
+ 1. Assert: The VariableEnvironment and LexicalEnvironment of _currentContext_ are the same.
+ 1. Assert: _environment_ and _originalEnv_ are the same.
+ 1. Let _paramVarEnv_ be NewDeclarativeEnvironment(_originalEnv_).
+ 1. Set the VariableEnvironment of _currentContext_ to _paramVarEnv_.
+ 1. Set the LexicalEnvironment of _currentContext_ to _paramVarEnv_.
+ 1. Let _result_ be the result of performing IteratorBindingInitialization for |BindingRestElement| using _iteratorRecord_ and _environment_ as the arguments.
+ 1. Set the VariableEnvironment of _currentContext_ to _originalEnv_.
+ 1. Set the LexicalEnvironment of _currentContext_ to _originalEnv_.
+ 1. Return _result_.
+
+
+
The new Environment Record created in step 6 is only used if the |BindingRestElement| contains a direct eval.
+
+
+
+
+
+
Runtime Semantics: InstantiateFunctionObject
+
With parameter _scope_.
+
+ FunctionDeclaration : `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+
+ 1. If the function code for |FunctionDeclaration| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _name_ be StringValue of |BindingIdentifier|.
+ 1. Let _F_ be FunctionCreate(~Normal~, |FormalParameters|, |FunctionBody|, _scope_, _strict_).
+ 1. Perform MakeConstructor(_F_).
+ 1. Perform SetFunctionName(_F_, _name_).
+ 1. Return _F_.
+
+ FunctionDeclaration : `function` `(` FormalParameters `)` `{` FunctionBody `}`
+
+ 1. If the function code for |FunctionDeclaration| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _F_ be FunctionCreate(~Normal~, |FormalParameters|, |FunctionBody|, _scope_, _strict_).
+ 1. Perform MakeConstructor(_F_).
+ 1. Perform SetFunctionName(_F_, `"default"`).
+ 1. Return _F_.
+
+
+
An anonymous |FunctionDeclaration| can only occur as part of an `export default` declaration.
+
+ FunctionDeclaration : `function` `(` FormalParameters `)` `{` FunctionBody `}`
+
+ 1. Return NormalCompletion(~empty~).
+
+ FunctionExpression : `function` `(` FormalParameters `)` `{` FunctionBody `}`
+
+ 1. If the function code for |FunctionExpression| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the LexicalEnvironment of the running execution context.
+ 1. Let _closure_ be FunctionCreate(~Normal~, |FormalParameters|, |FunctionBody|, _scope_, _strict_).
+ 1. Perform MakeConstructor(_closure_).
+ 1. Return _closure_.
+
+ FunctionExpression : `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+
+ 1. If the function code for |FunctionExpression| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the running execution context's LexicalEnvironment.
+ 1. Let _funcEnv_ be NewDeclarativeEnvironment(_scope_).
+ 1. Let _envRec_ be _funcEnv_'s EnvironmentRecord.
+ 1. Let _name_ be StringValue of |BindingIdentifier|.
+ 1. Perform _envRec_.CreateImmutableBinding(_name_).
+ 1. Let _closure_ be FunctionCreate(~Normal~, |FormalParameters|, |FunctionBody|, _funcEnv_, _strict_).
+ 1. Perform MakeConstructor(_closure_).
+ 1. Perform SetFunctionName(_closure_, _name_).
+ 1. Perform _envRec_.InitializeBinding(_name_, _closure_).
+ 1. Return _closure_.
+
+
+
The |BindingIdentifier| in a |FunctionExpression| can be referenced from inside the |FunctionExpression|'s |FunctionBody| to allow the function to call itself recursively. However, unlike in a |FunctionDeclaration|, the |BindingIdentifier| in a |FunctionExpression| cannot be referenced from and does not affect the scope enclosing the |FunctionExpression|.
+
+
+
A `prototype` property is automatically created for every function defined using a |FunctionDeclaration| or |FunctionExpression|, to allow for the possibility that the function will be used as a constructor.
When the production
+
+ ArrowParameters[Yield] : CoverParenthesizedExpressionAndArrowParameterList[?Yield]
+
+ is recognized the following grammar is used to refine the interpretation of |CoverParenthesizedExpressionAndArrowParameterList|:
+ If the [Yield] grammar parameter is present on |ArrowParameters|, it is a Syntax Error if the lexical token sequence matched by |CoverParenthesizedExpressionAndArrowParameterList[?Yield]| cannot be parsed with no tokens left over using |ArrowFormalParameters[Yield]| as the goal symbol.
+
+
+ If the [Yield] grammar parameter is not present on |ArrowParameters|, it is a Syntax Error if the lexical token sequence matched by |CoverParenthesizedExpressionAndArrowParameterList[?Yield]| cannot be parsed with no tokens left over using |ArrowFormalParameters| as the goal symbol.
+
+
+ All early errors rules for |ArrowFormalParameters| and its derived productions also apply to CoveredFormalsList of |CoverParenthesizedExpressionAndArrowParameterList[?Yield]|.
+
+
+
+
+
+
+
Static Semantics: BoundNames
+
+ ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList
+
+ 1. Let _formals_ be CoveredFormalsList of |CoverParenthesizedExpressionAndArrowParameterList|.
+ 1. Return the BoundNames of _formals_.
+
+
+
+
+
+
Static Semantics: Contains
+
With parameter _symbol_.
+
+ ArrowFunction : ArrowParameters `=>` ConciseBody
+
+ 1. If _symbol_ is not one of |NewTarget|, |SuperProperty|, |SuperCall|, `super` or `this`, return *false*.
+ 1. If |ArrowParameters| Contains _symbol_ is *true*, return *true*.
+ 1. Return |ConciseBody| Contains _symbol_ .
+
+
+
Normally, Contains does not look inside most function forms. However, Contains is used to detect `new.target`, `this`, and `super` usage within an |ArrowFunction|.
+
+ ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList
+
+ 1. Let _formals_ be CoveredFormalsList of |CoverParenthesizedExpressionAndArrowParameterList|.
+ 1. Return _formals_ Contains _symbol_.
+
+
+
+
+
+
+
+ ArrowParameters : BindingIdentifier
+
+ 1. Return *true*.
+
+ ArrowParameters : CoverParenthesizedExpressionAndArrowParameterList
+
+ 1. Let _formals_ be CoveredFormalsList of |CoverParenthesizedExpressionAndArrowParameterList|.
+ 1. Return IsSimpleParameterList of _formals_.
+
+
+
+
+
+
Static Semantics: CoveredFormalsList
+ ArrowParameters : BindingIdentifier
+
+ 1. Return this |ArrowParameters|.
+
+
+ CoverParenthesizedExpressionAndArrowParameterList[Yield] :
+ `(` Expression `)`
+ `(` `)`
+ `(` `...` BindingIdentifier `)`
+ `(` `...` BindingPattern `)`
+ `(` Expression `,` `...` BindingIdentifier `)`
+ `(` Expression `,` `...` BindingPattern `)`
+
+
+ 1. If the [Yield] grammar parameter is present for |CoverParenthesizedExpressionAndArrowParameterList[Yield]|, return the result of parsing the lexical token stream matched by |CoverParenthesizedExpressionAndArrowParameterList[Yield]| using |ArrowFormalParameters[Yield]| as the goal symbol.
+ 1. If the [Yield] grammar parameter is not present for |CoverParenthesizedExpressionAndArrowParameterList[Yield]|, return the result of parsing the lexical token stream matched by |CoverParenthesizedExpressionAndArrowParameterList| using |ArrowFormalParameters| as the goal symbol.
+
+
+
+
+
+
With parameters _iteratorRecord_ and _environment_.
+
+
+
When *undefined* is passed for _environment_ it indicates that a PutValue operation should be used to assign the initialization value. This is the case for formal parameter lists of non-strict functions. In that case the formal parameter bindings are preinitialized in order to deal with the possibility of multiple parameters with the same name.
+
+ ArrowParameters : BindingIdentifier
+
+ 1. Assert: _iteratorRecord_.[[done]] is *false*.
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, set _iteratorRecord_.[[done]] to *true*.
+ 1. Else,
+ 1. Let _v_ be IteratorValue(_next_).
+ 1. If _v_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_v_).
+ 1. If _iteratorRecord_.[[done]] is *true*, let _v_ be *undefined*.
+ 1. Return the result of performing BindingInitialization for |BindingIdentifier| using _v_ and _environment_ as the arguments.
+
+
+
+
+
+
Runtime Semantics: EvaluateBody
+
With parameter _functionObject_.
+
+ ConciseBody : AssignmentExpression
+
+ 1. Let _exprRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _exprValue_ be ? GetValue(_exprRef_).
+ 1. Return Completion{[[type]]: ~return~, [[value]]: _exprValue_, [[target]]: ~empty~}.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ ArrowFunction : ArrowParameters `=>` ConciseBody
+
+ 1. If the function code for this |ArrowFunction| is strict mode code (), let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the LexicalEnvironment of the running execution context.
+ 1. Let _parameters_ be CoveredFormalsList of |ArrowParameters|.
+ 1. Let _closure_ be FunctionCreate(~Arrow~, _parameters_, |ConciseBody|, _scope_, _strict_).
+ 1. Return _closure_.
+
+
+
An |ArrowFunction| does not define local bindings for `arguments`, `super`, `this`, or `new.target`. Any reference to `arguments`, `super`, `this`, or `new.target` within an |ArrowFunction| must resolve to a binding in a lexically enclosing environment. Typically this will be the Function Environment of an immediately enclosing function. Even though an |ArrowFunction| may contain references to `super`, the function object created in step 4 is not made into a method by performing MakeMethod. An |ArrowFunction| that references `super` is always contained within a non-|ArrowFunction| and the necessary state to implement `super` is accessible via the _scope_ that is captured by the function object of the |ArrowFunction|.
With parameters _object_ and optional parameter _functionPrototype_.
+ MethodDefinition : PropertyName `(` StrictFormalParameters `)` `{` FunctionBody `}`
+
+ 1. Let _propKey_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_propKey_).
+ 1. If the function code for this |MethodDefinition| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the running execution context's LexicalEnvironment.
+ 1. If _functionPrototype_ was passed as a parameter, let _kind_ be ~Normal~; otherwise let _kind_ be ~Method~.
+ 1. Let _closure_ be FunctionCreate(_kind_, |StrictFormalParameters|, |FunctionBody|, _scope_, _strict_). If _functionPrototype_ was passed as a parameter then pass its value as the _functionPrototype_ optional argument of FunctionCreate.
+ 1. Perform MakeMethod(_closure_, _object_).
+ 1. Return the Record{[[key]]: _propKey_, [[closure]]: _closure_}.
+
+
+
+
+
+
Runtime Semantics: PropertyDefinitionEvaluation
+
With parameters _object_ and _enumerable_.
+
+ MethodDefinition : PropertyName `(` StrictFormalParameters `)` `{` FunctionBody `}`
+
+ 1. Let _methodDef_ be DefineMethod of |MethodDefinition| with argument _object_.
+ 1. ReturnIfAbrupt(_methodDef_).
+ 1. Perform SetFunctionName(_methodDef_.[[closure]], _methodDef_.[[key]]).
+ 1. Let _desc_ be the Property Descriptor{[[Value]]: _methodDef_.[[closure]], [[Writable]]: *true*, [[Enumerable]]: _enumerable_, [[Configurable]]: *true*}.
+ 1. Return DefinePropertyOrThrow(_object_, _methodDef_.[[key]], _desc_).
+
+ MethodDefinition : GeneratorMethod
+
See .
+ MethodDefinition : `get` PropertyName `(` `)` `{` FunctionBody `}`
+
+ 1. Let _propKey_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_propKey_).
+ 1. If the function code for this |MethodDefinition| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the running execution context's LexicalEnvironment.
+ 1. Let _formalParameterList_ be the production FormalParameters : [empty].
+ 1. Let _closure_ be FunctionCreate(~Method~, _formalParameterList_, |FunctionBody|, _scope_, _strict_).
+ 1. Perform MakeMethod(_closure_, _object_).
+ 1. Perform SetFunctionName(_closure_, _propKey_, `"get"`).
+ 1. Let _desc_ be the PropertyDescriptor{[[Get]]: _closure_, [[Enumerable]]: _enumerable_, [[Configurable]]: *true*}.
+ 1. Return DefinePropertyOrThrow(_object_, _propKey_, _desc_).
+
+ MethodDefinition : `set` PropertyName `(` PropertySetParameterList `)` `{` FunctionBody `}`
+
+ 1. Let _propKey_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_propKey_).
+ 1. If the function code for this |MethodDefinition| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the running execution context's LexicalEnvironment.
+ 1. Let _closure_ be FunctionCreate(~Method~, |PropertySetParameterList|, |FunctionBody|, _scope_, _strict_).
+ 1. Perform MakeMethod(_closure_, _object_).
+ 1. Perform SetFunctionName(_closure_, _propKey_, `"set"`).
+ 1. Let _desc_ be the PropertyDescriptor{[[Set]]: _closure_, [[Enumerable]]: _enumerable_, [[Configurable]]: *true*}.
+ 1. Return DefinePropertyOrThrow(_object_, _propKey_, _desc_).
+
+
+
+
+
+
+
The syntactic context immediately following `yield` requires use of the |InputElementRegExpOrTemplateTail| lexical goal.
+
+
+
|YieldExpression| cannot be used within the |FormalParameters| of a generator function because any expressions that are part of |FormalParameters| are evaluated before the resulting generator object is in a resumable state.
+
+
+
Abstract operations relating to generator objects are defined in .
+ If the source code matching this production is strict code, the Early Error rules for StrictFormalParameters : FormalParameters are applied.
+
+
+ If the source code matching this production is strict code, it is a Syntax Error if |BindingIdentifier| is the |IdentifierName| `eval` or the |IdentifierName| `arguments`.
+
+
+ It is a Syntax Error if ContainsUseStrict of |GeneratorBody| is *true* and IsSimpleParameterList of |FormalParameters| is *false*.
+
+
+ It is a Syntax Error if any element of the BoundNames of |FormalParameters| also occurs in the LexicallyDeclaredNames of |GeneratorBody|.
+
+
+ It is a Syntax Error if |FormalParameters| Contains |YieldExpression| is *true*.
+
+
+ It is a Syntax Error if |FormalParameters| Contains |SuperProperty| is *true*.
+
+
+ It is a Syntax Error if |GeneratorBody| Contains |SuperProperty| is *true*.
+
+
+ It is a Syntax Error if |FormalParameters| Contains |SuperCall| is *true*.
+
+
+ It is a Syntax Error if |GeneratorBody| Contains |SuperCall| is *true*.
+
If the generator was invoked using [[Call]], the `this` binding will have already been initialized in the normal manner. If the generator was invoked using [[Construct]], the `this` bind is not initialized and any references to `this` within the |FunctionBody| will produce a *ReferenceError* exception.
+
+
+
+
+
+
Runtime Semantics: InstantiateFunctionObject
+
With parameter _scope_.
+
+ GeneratorDeclaration : `function` `*` BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+
+ 1. If the function code for |GeneratorDeclaration| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _name_ be StringValue of |BindingIdentifier|.
+ 1. Let _F_ be GeneratorFunctionCreate(~Normal~, |FormalParameters|, |GeneratorBody|, _scope_, _strict_).
+ 1. Let _prototype_ be ObjectCreate(%GeneratorPrototype%).
+ 1. Perform DefinePropertyOrThrow(_F_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Perform SetFunctionName(_F_, _name_).
+ 1. Return _F_.
+
+ GeneratorDeclaration : `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+
+ 1. If the function code for |GeneratorDeclaration| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _F_ be GeneratorFunctionCreate(~Normal~, |FormalParameters|, |GeneratorBody|, _scope_, _strict_).
+ 1. Let _prototype_ be ObjectCreate(%GeneratorPrototype%).
+ 1. Perform DefinePropertyOrThrow(_F_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Perform SetFunctionName(_F_, `"default"`).
+ 1. Return _F_.
+
+
+
An anonymous |GeneratorDeclaration| can only occur as part of an `export default` declaration.
+
+
+
+
+
+
Runtime Semantics: PropertyDefinitionEvaluation
+
With parameter _object_ and _enumerable_.
+
+ GeneratorMethod : `*` PropertyName `(` StrictFormalParameters `)` `{` GeneratorBody `}`
+
+ 1. Let _propKey_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_propKey_).
+ 1. If the function code for this |GeneratorMethod| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the running execution context's LexicalEnvironment.
+ 1. Let _closure_ be GeneratorFunctionCreate(~Method~, |StrictFormalParameters|, |GeneratorBody|, _scope_, _strict_).
+ 1. Perform MakeMethod(_closure_, _object_).
+ 1. Let _prototype_ be ObjectCreate(%GeneratorPrototype%).
+ 1. Perform DefinePropertyOrThrow(_closure_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Perform SetFunctionName(_closure_, _propKey_).
+ 1. Let _desc_ be the Property Descriptor{[[Value]]: _closure_, [[Writable]]: *true*, [[Enumerable]]: _enumerable_, [[Configurable]]: *true*}.
+ 1. Return DefinePropertyOrThrow(_object_, _propKey_, _desc_).
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ GeneratorExpression : `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+
+ 1. If the function code for this |GeneratorExpression| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the LexicalEnvironment of the running execution context.
+ 1. Let _closure_ be GeneratorFunctionCreate(~Normal~, |FormalParameters|, |GeneratorBody|, _scope_, _strict_).
+ 1. Let _prototype_ be ObjectCreate(%GeneratorPrototype%).
+ 1. Perform DefinePropertyOrThrow(_closure_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Return _closure_.
+
+ GeneratorExpression : `function` `*` BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+
+ 1. If the function code for this |GeneratorExpression| is strict mode code, let _strict_ be *true*. Otherwise let _strict_ be *false*.
+ 1. Let _scope_ be the running execution context's LexicalEnvironment.
+ 1. Let _funcEnv_ be NewDeclarativeEnvironment(_scope_).
+ 1. Let _envRec_ be _funcEnv_'s EnvironmentRecord.
+ 1. Let _name_ be StringValue of |BindingIdentifier|.
+ 1. Perform _envRec_.CreateImmutableBinding(_name_).
+ 1. Let _closure_ be GeneratorFunctionCreate(~Normal~, |FormalParameters|, |GeneratorBody|, _funcEnv_, _strict_).
+ 1. Let _prototype_ be ObjectCreate(%GeneratorPrototype%).
+ 1. Perform DefinePropertyOrThrow(_closure_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Perform SetFunctionName(_closure_, _name_).
+ 1. Perform _envRec_.InitializeBinding(_name_, _closure_).
+ 1. Return _closure_.
+
+
+
The |BindingIdentifier| in a |GeneratorExpression| can be referenced from inside the |GeneratorExpression|'s |FunctionBody| to allow the generator code to call itself recursively. However, unlike in a |GeneratorDeclaration|, the |BindingIdentifier| in a |GeneratorExpression| cannot be referenced from and does not affect the scope enclosing the |GeneratorExpression|.
+
+ YieldExpression : `yield`
+
+ 1. Return GeneratorYield(CreateIterResultObject(*undefined*, *false*)).
+
+ YieldExpression : `yield` AssignmentExpression
+
+ 1. Let _exprRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _value_ be ? GetValue(_exprRef_).
+ 1. Return GeneratorYield(CreateIterResultObject(_value_, *false*)).
+
+ YieldExpression : `yield` `*` AssignmentExpression
+
+ 1. Let _exprRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _value_ be GetValue(_exprRef_).
+ 1. Let _iterator_ be ? GetIterator(_value_).
+ 1. Let _received_ be NormalCompletion(*undefined*).
+ 1. Repeat
+ 1. If _received_.[[type]] is ~normal~, then
+ 1. Let _innerResult_ be ? IteratorNext(_iterator_, _received_.[[value]]).
+ 1. Let _done_ be ? IteratorComplete(_innerResult_).
+ 1. If _done_ is *true*, then
+ 1. Return IteratorValue(_innerResult_).
+ 1. Let _received_ be GeneratorYield(_innerResult_).
+ 1. Else if _received_.[[type]] is ~throw~, then
+ 1. Let _throw_ be ? GetMethod(_iterator_, `"throw"`).
+ 1. If _throw_ is not *undefined*, then
+ 1. Let _innerResult_ be ? Call(_throw_, _iterator_, « _received_.[[value]] »).
+ 1. NOTE: Exceptions from the inner iterator `throw` method are propagated. Normal completions from an inner `throw` method are processed similarly to an inner `next`.
+ 1. If Type(_innerResult_) is not Object, throw a *TypeError* exception.
+ 1. Let _done_ be ? IteratorComplete(_innerResult_).
+ 1. If _done_ is *true*, then
+ 1. Let _value_ be ? IteratorValue(_innerResult_).
+ 1. Return Completion{[[type]]: ~return~ , [[value]]:_value_, [[target]]:~empty~}.
+ 1. Let _received_ be GeneratorYield(_innerResult_).
+ 1. Else,
+ 1. NOTE: If _iterator_ does not have a `throw` method, this throw is going to terminate the `yield*` loop. But first we need to give _iterator_ a chance to clean up.
+ 1. Let _closeResult_ be ? IteratorClose(_iterator_, Completion{[[type]]: ~normal~ , [[value]]: ~empty~, [[target]]:~empty~}).
+ 1. NOTE: The next step throws a *TypeError* to indicate that there was a `yield*` protocol violation: _iterator_ does not have a `throw` method.
+ 1. Throw a *TypeError* exception.
+ 1. Else,
+ 1. Assert: _received_.[[type]] is ~return~.
+ 1. Let _return_ be ? GetMethod(_iterator_, `"return"`).
+ 1. If _return_ is *undefined*, return Completion(_received_).
+ 1. Let _innerReturnResult_ be ? Call(_return_, _iterator_, « _received_.[[value]] »).
+ 1. If Type(_innerReturnResult_) is not Object, throw a *TypeError* exception.
+ 1. Let _done_ be ? IteratorComplete(_innerReturnResult_).
+ 1. If _done_ is *true*, then
+ 1. Let _value_ be ? IteratorValue(_innerReturnResult_).
+ 1. Return Completion{[[type]]: ~return~ , [[value]]: _value_, [[target]]:~empty~}.
+ 1. Let _received_ be GeneratorYield(_innerReturnResult_).
+
+
+
+
+
+
+
It is a Syntax Error if |ClassHeritage| is not present and the following algorithm evaluates to *true*:
+
+ 1. Let _constructor_ be ConstructorMethod of |ClassBody|.
+ 1. If _constructor_ is ~empty~, return *false*.
+ 1. Return HasDirectSuper of _constructor_.
+
+
+
+ ClassBody : ClassElementList
+
+
+ It is a Syntax Error if PrototypePropertyNameList of |ClassElementList| contains more than one occurrence of `"constructor"`.
+
+
+ ClassElement : MethodDefinition
+
+
+ It is a Syntax Error if PropName of |MethodDefinition| is not `"constructor"` and HasDirectSuper of |MethodDefinition| is *true*.
+
+
+ It is a Syntax Error if PropName of |MethodDefinition| is `"constructor"` and SpecialMethod of |MethodDefinition| is *true*.
+
+
+ ClassElement : `static` MethodDefinition
+
+
+ It is a Syntax Error if HasDirectSuper of |MethodDefinition| is *true*.
+
+
+ It is a Syntax Error if PropName of |MethodDefinition| is `"prototype"`.
+
+ ClassElementList : ClassElement
+
+ 1. If |ClassElement| is the production ClassElement : `;` , return ~empty~.
+ 1. If IsStatic of |ClassElement| is *true*, return ~empty~.
+ 1. If PropName of |ClassElement| is not `"constructor"`, return ~empty~.
+ 1. Return |ClassElement|.
+
+ ClassElementList : ClassElementList ClassElement
+
+ 1. Let _head_ be ConstructorMethod of |ClassElementList|.
+ 1. If _head_ is not ~empty~, return _head_.
+ 1. If |ClassElement| is the production ClassElement : `;` , return ~empty~.
+ 1. If IsStatic of |ClassElement| is *true*, return ~empty~.
+ 1. If PropName of |ClassElement| is not `"constructor"`, return ~empty~.
+ 1. Return |ClassElement|.
+
+
+
Early Error rules ensure that there is only one method definition named `"constructor"` and that it is not an accessor property or generator definition.
+
+
+
+
+
+
Static Semantics: Contains
+
With parameter _symbol_.
+
+ ClassTail : ClassHeritage? `{` ClassBody `}`
+
+ 1. If _symbol_ is |ClassBody|, return *true*.
+ 1. If _symbol_ is |ClassHeritage|, then
+ 1. If |ClassHeritage| is present, return *true*; otherwise return *false*.
+ 1. Let _inHeritage_ be |ClassHeritage| Contains _symbol_.
+ 1. If _inHeritage_ is *true*, return *true*.
+ 1. Return the result of ComputedPropertyContains for |ClassBody| with argument _symbol_.
+
+
+
Static semantic rules that depend upon substructure generally do not look into class bodies except for |PropertyName| productions.
+
+
+
+
+
+
Static Semantics: ComputedPropertyContains
+
With parameter _symbol_.
+
+ ClassElementList : ClassElementList ClassElement
+
+ 1. Let _inList_ be the result of ComputedPropertyContains for |ClassElementList| with argument _symbol_.
+ 1. If _inList_ is *true*, return *true*.
+ 1. Return the result of ComputedPropertyContains for |ClassElement| with argument _symbol_.
+
+ ClassElement : MethodDefinition
+
+ 1. Return the result of ComputedPropertyContains for |MethodDefinition| with argument _symbol_.
+
+ ClassElement : `static` MethodDefinition
+
+ 1. Return the result of ComputedPropertyContains for |MethodDefinition| with argument _symbol_.
+
+ ClassElement : `;`
+
+ 1. Return *false*.
+
+
+
+
+
+
+ ClassElementList : ClassElement
+
+ 1. If |ClassElement| is the production ClassElement : `;` , return a new empty List.
+ 1. If IsStatic of |ClassElement| is *false* and PropName of |ClassElement| is `"constructor"`, return a new empty List.
+ 1. Return a List containing |ClassElement|.
+
+ ClassElementList : ClassElementList ClassElement
+
+ 1. Let _list_ be NonConstructorMethodDefinitions of |ClassElementList|.
+ 1. If |ClassElement| is the production ClassElement : `;` , return _list_.
+ 1. If IsStatic of |ClassElement| is *false* and PropName of |ClassElement| is `"constructor"`, return _list_.
+ 1. Append |ClassElement| to the end of _list_.
+ 1. Return _list_.
+
+
+
+
+
+
Static Semantics: PrototypePropertyNameList
+ ClassElementList : ClassElement
+
+ 1. If PropName of |ClassElement| is ~empty~, return a new empty List.
+ 1. If IsStatic of |ClassElement| is *true*, return a new empty List.
+ 1. Return a List containing PropName of |ClassElement|.
+
+ ClassElementList : ClassElementList ClassElement
+
+ 1. Let _list_ be PrototypePropertyNameList of |ClassElementList|.
+ 1. If PropName of |ClassElement| is ~empty~, return _list_.
+ 1. If IsStatic of |ClassElement| is *true*, return _list_.
+ 1. Append PropName of |ClassElement| to the end of _list_.
+ 1. Return _list_.
+
+
+
+
+
+
+ ClassElementList : ClassElement
+
+ 1. If PropName of |ClassElement| is ~empty~, return a new empty List.
+ 1. If IsStatic of |ClassElement| is *false*, return a new empty List.
+ 1. Return a List containing PropName of |ClassElement|.
+
+ ClassElementList : ClassElementList ClassElement
+
+ 1. Let _list_ be StaticPropertyNameList of |ClassElementList|.
+ 1. If PropName of |ClassElement| is ~empty~, return _list_.
+ 1. If IsStatic of |ClassElement| is *false*, return _list_.
+ 1. Append PropName of |ClassElement| to the end of _list_.
+ 1. Return _list_.
+
+
+
+
+
+
Runtime Semantics: ClassDefinitionEvaluation
+
With parameter _className_.
+ ClassTail : ClassHeritage? `{` ClassBody? `}`
+
+ 1. Let _lex_ be the LexicalEnvironment of the running execution context.
+ 1. Let _classScope_ be NewDeclarativeEnvironment(_lex_).
+ 1. Let _classScopeEnvRec_ be _classScope_'s EnvironmentRecord.
+ 1. If _className_ is not *undefined*, then
+ 1. Perform _classScopeEnvRec_.CreateImmutableBinding(_className_, *true*).
+ 1. If |ClassHeritage_opt| is not present, then
+ 1. Let _protoParent_ be the intrinsic object %ObjectPrototype%.
+ 1. Let _constructorParent_ be the intrinsic object %FunctionPrototype%.
+ 1. Else,
+ 1. Set the running execution context's LexicalEnvironment to _classScope_.
+ 1. Let _superclass_ be the result of evaluating |ClassHeritage|.
+ 1. Set the running execution context's LexicalEnvironment to _lex_.
+ 1. ReturnIfAbrupt(_superclass_).
+ 1. If _superclass_ is *null*, then
+ 1. Let _protoParent_ be *null*.
+ 1. Let _constructorParent_ be the intrinsic object %FunctionPrototype%.
+ 1. Else if IsConstructor(_superclass_) is *false*, throw a *TypeError* exception.
+ 1. Else,
+ 1. Let _protoParent_ be ? Get(_superclass_, `"prototype"`).
+ 1. If Type(_protoParent_) is neither Object nor Null, throw a *TypeError* exception.
+ 1. Let _constructorParent_ be _superclass_.
+ 1. Let _proto_ be ObjectCreate(_protoParent_).
+ 1. If |ClassBody_opt| is not present, let _constructor_ be ~empty~.
+ 1. Else, let _constructor_ be ConstructorMethod of |ClassBody|.
+ 1. If _constructor_ is ~empty~, then
+ 1. If |ClassHeritage_opt| is present, then
+ 1. Let _constructor_ be the result of parsing the source text
+
constructor(... args){ super (...args);}
+ using the syntactic grammar with the goal symbol |MethodDefinition|.
+ 1. Else,
+ 1. Let _constructor_ be the result of parsing the source text
+
constructor( ){ }
+ using the syntactic grammar with the goal symbol |MethodDefinition|.
+ 1. Set the running execution context's LexicalEnvironment to _classScope_.
+ 1. Let _constructorInfo_ be the result of performing DefineMethod for _constructor_ with arguments _proto_ and _constructorParent_ as the optional _functionPrototype_ argument.
+ 1. Assert: _constructorInfo_ is not an abrupt completion.
+ 1. Let _F_ be _constructorInfo_.[[closure]].
+ 1. If |ClassHeritage_opt| is present, set _F_'s [[ConstructorKind]] internal slot to `"derived"`.
+ 1. Perform MakeConstructor(_F_, *false*, _proto_).
+ 1. Perform MakeClassConstructor(_F_).
+ 1. Perform CreateMethodProperty(_proto_, `"constructor"`, _F_).
+ 1. If |ClassBody_opt| is not present, let _methods_ be a new empty List.
+ 1. Else, let _methods_ be NonConstructorMethodDefinitions of |ClassBody|.
+ 1. For each |ClassElement| _m_ in order from _methods_
+ 1. If IsStatic of _m_ is *false*, then
+ 1. Let _status_ be the result of performing PropertyDefinitionEvaluation for _m_ with arguments _proto_ and *false*.
+ 1. Else,
+ 1. Let _status_ be the result of performing PropertyDefinitionEvaluation for _m_ with arguments _F_ and *false*.
+ 1. If _status_ is an abrupt completion, then
+ 1. Set the running execution context's LexicalEnvironment to _lex_.
+ 1. Return Completion(_status_).
+ 1. Set the running execution context's LexicalEnvironment to _lex_.
+ 1. If _className_ is not *undefined*, then
+ 1. Perform _classScopeEnvRec_.InitializeBinding(_className_, _F_).
+ 1. Return _F_.
+
+
+
+
+
+
+ ClassDeclaration : `class` BindingIdentifier ClassTail
+
+ 1. Let _className_ be StringValue of |BindingIdentifier|.
+ 1. Let _value_ be the result of ClassDefinitionEvaluation of |ClassTail| with argument _className_.
+ 1. ReturnIfAbrupt(_value_).
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_value_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_value_, _className_).
+ 1. Let _env_ be the running execution context's LexicalEnvironment.
+ 1. Let _status_ be ? InitializeBoundName(_className_, _value_, _env_).
+ 1. Return _value_.
+
+ ClassDeclaration : `class` ClassTail
+
+ 1. Return the result of ClassDefinitionEvaluation of |ClassTail| with argument *undefined*.
+
+
+
ClassDeclaration : `class` ClassTail only occurs as part of an |ExportDeclaration| and the setting of a name property and establishing its binding are handled as part of the evaluation action for that production. See .
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ ClassDeclaration : `class` BindingIdentifier ClassTail
+
+ 1. Let _status_ be the result of BindingClassDeclarationEvaluation of this |ClassDeclaration|.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return NormalCompletion(~empty~).
+
+
+
ClassDeclaration : `class` ClassTail only occurs as part of an |ExportDeclaration| and is never directly evaluated.
+
+ ClassExpression : `class` BindingIdentifier? ClassTail
+
+ 1. If |BindingIdentifier_opt| is not present, let _className_ be *undefined*.
+ 1. Else, let _className_ be StringValue of |BindingIdentifier|.
+ 1. Let _value_ be the result of ClassDefinitionEvaluation of |ClassTail| with argument _className_.
+ 1. ReturnIfAbrupt(_value_).
+ 1. If _className_ is not *undefined*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_value_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, then
+ 1. Perform SetFunctionName(_value_, _className_).
+ 1. Return NormalCompletion(_value_).
+
+
+
If the class definition included a `name` static method then that method is not over-written with a `name` data property for the class name.
+
+
+
+
+
+
+
Tail Position Calls
+
+
+
+
Static Semantics: IsInTailPosition(_nonterminal_)
+
The abstract operation IsInTailPosition with argument _nonterminal_ performs the following steps:
+
+ 1. Assert: _nonterminal_ is a parsed grammar production.
+ 1. If the source code matching _nonterminal_ is not strict code, return *false*.
+ 1. If _nonterminal_ is not contained within a |FunctionBody| or |ConciseBody|, return *false*.
+ 1. Let _body_ be the |FunctionBody| or |ConciseBody| that most closely contains _nonterminal_.
+ 1. If _body_ is the |FunctionBody| of a |GeneratorBody|, return *false*.
+ 1. Return the result of HasProductionInTailPosition of _body_ with argument _nonterminal_.
+
+
+
Tail Position calls are only defined in strict mode code because of a common non-standard language extension (see ) that enables observation of the chain of caller contexts.
+
+
+
+
+
+
Static Semantics: HasProductionInTailPosition
+
With parameter _nonterminal_.
+
+
_nonterminal_ is a parsed grammar production that represents a specific range of source text. When the following algorithms compare _nonterminal_ to other grammar symbols they are testing whether the same source text was matched by both symbols.
+
+
+
+
+
Statement Rules
+ ConciseBody : AssignmentExpression
+
+ 1. Return HasProductionInTailPosition of |AssignmentExpression| with argument _nonterminal_.
+
+ StatementList : StatementList StatementListItem
+
+ 1. Let _has_ be HasProductionInTailPosition of |StatementList| with argument _nonterminal_.
+ 1. If _has_ is *true*, return *true*.
+ 1. Return HasProductionInTailPosition of |StatementListItem| with argument _nonterminal_.
+
+
+ FunctionStatementList : [empty]
+
+ StatementListItem : Declaration
+
+ Statement :
+ VariableStatement
+ EmptyStatement
+ ExpressionStatement
+ ContinueStatement
+ BreakStatement
+ ThrowStatement
+ DebuggerStatement
+
+ Block : `{` `}`
+
+ ReturnStatement : `return` `;`
+
+ LabelledItem : FunctionDeclaration
+
+ IterationStatement :
+ `for` `(` LeftHandSideExpression `in` Expression `)` Statement
+ `for` `(` `var` ForBinding `in` Expression `)` Statement
+ `for` `(` ForDeclaration `in` Expression `)` Statement
+ `for` `(` LeftHandSideExpression `of` AssignmentExpression `)` Statement
+ `for` `(` `var` ForBinding `of` AssignmentExpression `)` Statement
+ `for` `(` ForDeclaration `of` AssignmentExpression `)` Statement
+
+ CaseBlock : `{` `}`
+
+
+ 1. Return *false*.
+
+ IfStatement : `if` `(` Expression `)` Statement `else` Statement
+
+ 1. Let _has_ be HasProductionInTailPosition of the first |Statement| with argument _nonterminal_.
+ 1. If _has_ is *true*, return *true*.
+ 1. Return HasProductionInTailPosition of the second |Statement| with argument _nonterminal_.
+
+
+ IfStatement : `if` `(` Expression `)` Statement
+
+ IterationStatement :
+ `do` Statement `while` `(` Expression `)` `;`
+ `while` `(` Expression `)` Statement
+ `for` `(` Expression? `;` Expression? `;` Expression? `)` Statement
+ `for` `(` `var` VariableDeclarationList `;` Expression? `;` Expression? `)` Statement
+ `for` `(` LexicalDeclaration Expression? `;` Expression? `)` Statement
+
+ WithStatement : `with` `(` Expression `)` Statement
+
+
+ 1. Return HasProductionInTailPosition of |Statement| with argument _nonterminal_.
+
+
+ LabelledStatement :
+ LabelIdentifier `:` LabelledItem
+
+
+ 1. Return HasProductionInTailPosition of |LabelledItem| with argument _nonterminal_.
+
+ ReturnStatement : `return` Expression `;`
+
+ 1. Return HasProductionInTailPosition of |Expression| with argument _nonterminal_.
+
+ SwitchStatement : `switch` `(` Expression `)` CaseBlock
+
+ 1. Return HasProductionInTailPosition of |CaseBlock| with argument _nonterminal_.
+
+ CaseBlock : `{` CaseClauses? DefaultClause CaseClauses? `}`
+
+ 1. Let _has_ be *false*.
+ 1. If the first |CaseClauses| is present, let _has_ be HasProductionInTailPosition of the first |CaseClauses| with argument _nonterminal_.
+ 1. If _has_ is *true*, return *true*.
+ 1. Let _has_ be HasProductionInTailPosition of the |DefaultClause| with argument _nonterminal_.
+ 1. If _has_ is *true*, return *true*.
+ 1. If the second |CaseClauses| is present, let _has_ be HasProductionInTailPosition of the second |CaseClauses| with argument _nonterminal_.
+ 1. Return _has_.
+
+ CaseClauses : CaseClauses CaseClause
+
+ 1. Let _has_ be HasProductionInTailPosition of |CaseClauses| with argument _nonterminal_.
+ 1. If _has_ is *true*, return *true*.
+ 1. Return HasProductionInTailPosition of |CaseClause| with argument _nonterminal_.
+
+
+ CaseClause : `case` Expression `:` StatementList?
+
+ DefaultClause : `default` `:` StatementList?
+
+
+ 1. If |StatementList| is present, return HasProductionInTailPosition of |StatementList| with argument _nonterminal_.
+ 1. Return *false*.
+
+ TryStatement : `try` Block Catch
+
+ 1. Return HasProductionInTailPosition of |Catch| with argument _nonterminal_.
+
+
+ TryStatement : `try` Block Finally
+
+ TryStatement : `try` Block Catch Finally
+
+
+ 1. Return HasProductionInTailPosition of |Finally| with argument _nonterminal_.
+
+ Catch : `catch` `(` CatchParameter `)` Block
+
+ 1. Return HasProductionInTailPosition of |Block| with argument _nonterminal_.
+
+
+
+
+
+
Expression Rules
+
+
A potential tail position call that is immediately followed by return GetValue of the call result is also a possible tail position call. Function calls cannot return reference values, so such a GetValue operation will always returns the same value as the actual function call result.
The abstract operation PrepareForTailCall performs the following steps:
+
+ 1. Let _leafContext_ be the running execution context.
+ 1. Suspend _leafContext_.
+ 1. Pop _leafContext_ from the execution context stack. The execution context now on the top of the stack becomes the running execution context.
+ 1. Assert: _leafContext_ has no further use. It will never be activated as the running execution context.
+
+
A tail position call must either release any transient internal resources associated with the currently executing function execution context before invoking the target function or reuse those resources in support of the target function.
+
+
For example, a tail position call should only grow an implementation's activation record stack by the amount that the size of the target function's activation record exceeds the size of the calling function's activation record. If the target function's activation record is smaller, then the total size of the stack should decrease.
+ It is a Syntax Error if the LexicallyDeclaredNames of |ScriptBody| contains any duplicate entries.
+
+
+ It is a Syntax Error if any element of the LexicallyDeclaredNames of |ScriptBody| also occurs in the VarDeclaredNames of |ScriptBody|.
+
+
+ ScriptBody : StatementList
+
+
+ It is a Syntax Error if |StatementList| Contains `super` unless the source code containing `super` is eval code that is being processed by a direct `eval` that is contained in function code that is not the function code of an |ArrowFunction|.
+
+
+ It is a Syntax Error if |StatementList| Contains |NewTarget| unless the source code containing |NewTarget| is eval code that is being processed by a direct `eval` that is contained in function code that is not the function code of an |ArrowFunction|.
+
+
+ It is a Syntax Error if ContainsDuplicateLabels of |StatementList| with argument « » is *true*.
+
+
+ It is a Syntax Error if ContainsUndefinedBreakTarget of |StatementList| with argument « » is *true*.
+
+
+ It is a Syntax Error if ContainsUndefinedContinueTarget of |StatementList| with arguments « » and « » is *true*.
+
+
+
+
+
+
+
Static Semantics: IsStrict
+ ScriptBody : StatementList
+
+ 1. If the Directive Prologue of |StatementList| contains a Use Strict Directive, return *true*; otherwise, return *false*.
+
+
+
+
+
+
A Script Record encapsulates information about a script being evaluated. Each script record contains the fields listed in .
+
+
+
+
+
+
+ Field Name
+
+
+ Value Type
+
+
+ Meaning
+
+
+
+
+
+
+ [[Realm]]
+
+
+ Realm Record | *undefined*
+
+
+ The Realm within which this script was created. *undefined* if not yet assigned.
+
+
+
+
+ [[Environment]]
+
+
+ Lexical Environment | *undefined*
+
+
+ The Lexical Environment containing the top level bindings for this script. This field is set when the script is instantiated.
+
+
+
+
+ [[ECMAScriptCode]]
+
+
+ a parse result
+
+
+ The result of parsing the source text of this module using |Script| as the goal symbol.
+
+
+
+
+ [[HostDefined]]
+
+
+ Any, default value is *undefined*.
+
+
+ Field reserved for use by host environments that need to associate additional information with a script.
+
+
+
+
+
+
+
+
+
ParseScript ( _sourceText_, _hostDefined_ )
+
+
The abstract operation ParseScript with arguments _sourceText_ and _hostDefined_ creates a Script Record based upon the result of parsing _sourceText_ as a |Script|. ParseScript performs the following steps:
+
+
+ 1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
+ 1. Parse _sourceText_ using |Script| as the goal symbol and analyze the parse result for any Early Error conditions. If the parse was successful and no early errors were found, let _body_ be the resulting parse tree. Otherwise, let _body_ be an indication of one or more parsing errors and/or early errors. Parsing and early error detection may be interweaved in an implementation dependent manner. If more than one parse or early error is present, the number and ordering of reported errors is implementation dependent but at least one error must be reported.
+ 1. If _body_ is an abrupt completion or error indication, then
+ 1. Throw a SyntaxError exception.
+ 1. Return Script Record {[[Realm]]: *undefined*, [[Environment]]: *undefined*, [[ECMAScriptCode]]: _body_, [[HostDefined]]: _hostDefined_}.
+
+
+
An implementation may parse script source text and analyze it for Early Error conditions prior to evaluation of ParseScript for that script source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseScript upon that source text.
+
+
+
+
+
+
ScriptEvaluation ( _scriptRecord_ )
+
+
+ 1. Let _globalEnv_ be _scriptRecord_.[[Realm]].[[globalEnv]].
+ 1. Let _scriptCxt_ be a new ECMAScript code execution context.
+ 1. Set the Function of _scriptCxt_ to *null*.
+ 1. Set the Realm of _scriptCxt_ to _scriptRecord_.[[Realm]].
+ 1. Set the ScriptOrModule of _scriptCxt_ to _scriptRecord_.
+ 1. Set the VariableEnvironment of _scriptCxt_ to _globalEnv_.
+ 1. Set the LexicalEnvironment of _scriptCxt_ to _globalEnv_.
+ 1. Suspend the currently running execution context.
+ 1. Push _scriptCxt_ on to the execution context stack; _scriptCxt_ is now the running execution context.
+ 1. Let _result_ be GlobalDeclarationInstantiation(|ScriptBody|, _globalEnv_).
+ 1. If _result_.[[type]] is ~normal~, then
+ 1. Let _result_ be the result of evaluating |ScriptBody|.
+ 1. If _result_.[[type]] is ~normal~ and _result_.[[value]] is ~empty~, then
+ 1. Let _result_ be NormalCompletion(*undefined*).
+ 1. Suspend _scriptCxt_ and remove it from the execution context stack.
+ 1. Assert: the execution context stack is not empty.
+ 1. Resume the context that is now on the top of the execution context stack as the running execution context.
+ 1. Return Completion(_result_).
+
+
+
+
+
+
When an execution context is established for evaluating scripts, declarations are instantiated in the current global environment. Each global binding declared in the code is instantiated.
+
+
GlobalDeclarationInstantiation is performed as follows using arguments _script_ and _env_. _script_ is the |ScriptBody| for which the execution context is being established. _env_ is the global lexical environment in which bindings are to be created.
+
+ 1. Let _envRec_ be _env_'s EnvironmentRecord.
+ 1. Assert: _envRec_ is a global Environment Record.
+ 1. Let _lexNames_ be the LexicallyDeclaredNames of _script_.
+ 1. Let _varNames_ be the VarDeclaredNames of _script_.
+ 1. For each _name_ in _lexNames_, do
+ 1. If _envRec_.HasVarDeclaration(_name_) is *true*, throw a *SyntaxError* exception.
+ 1. If _envRec_.HasLexicalDeclaration(_name_) is *true*, throw a *SyntaxError* exception.
+ 1. Let _hasRestrictedGlobal_ be ? _envRec_.HasRestrictedGlobalProperty(_name_).
+ 1. If _hasRestrictedGlobal_ is *true*, throw a *SyntaxError* exception.
+ 1. For each _name_ in _varNames_, do
+ 1. If _envRec_.HasLexicalDeclaration(_name_) is *true*, throw a *SyntaxError* exception.
+ 1. Let _varDeclarations_ be the VarScopedDeclarations of _script_.
+ 1. Let _functionsToInitialize_ be an empty List.
+ 1. Let _declaredFunctionNames_ be an empty List.
+ 1. For each _d_ in _varDeclarations_, in reverse list order do
+ 1. If _d_ is neither a |VariableDeclaration| or a |ForBinding|, then
+ 1. Assert: _d_ is either a |FunctionDeclaration| or a |GeneratorDeclaration|.
+ 1. NOTE If there are multiple |FunctionDeclaration|s for the same name, the last declaration is used.
+ 1. Let _fn_ be the sole element of the BoundNames of _d_.
+ 1. If _fn_ is not an element of _declaredFunctionNames_, then
+ 1. Let _fnDefinable_ be ? _envRec_.CanDeclareGlobalFunction(_fn_).
+ 1. If _fnDefinable_ is *false*, throw a *TypeError* exception.
+ 1. Append _fn_ to _declaredFunctionNames_.
+ 1. Insert _d_ as the first element of _functionsToInitialize_.
+ 1. Let _declaredVarNames_ be an empty List.
+ 1. For each _d_ in _varDeclarations_, do
+ 1. If _d_ is a |VariableDeclaration| or a |ForBinding|, then
+ 1. For each String _vn_ in the BoundNames of _d_, do
+ 1. If _vn_ is not an element of _declaredFunctionNames_, then
+ 1. Let _vnDefinable_ be ? _envRec_.CanDeclareGlobalVar(_vn_).
+ 1. If _vnDefinable_ is *false*, throw a *TypeError* exception.
+ 1. If _vn_ is not an element of _declaredVarNames_, then
+ 1. Append _vn_ to _declaredVarNames_.
+ 1. NOTE: No abnormal terminations occur after this algorithm step if the global object is an ordinary object. However, if the global object is a Proxy exotic object it may exhibit behaviours that cause abnormal terminations in some of the following steps.
+ 1. NOTE: Annex adds additional steps at this point.
+ 1. Let _lexDeclarations_ be the LexicallyScopedDeclarations of _script_.
+ 1. For each element _d_ in _lexDeclarations_ do
+ 1. NOTE Lexically declared names are only instantiated here but not initialized.
+ 1. For each element _dn_ of the BoundNames of _d_ do
+ 1. If IsConstantDeclaration of _d_ is *true*, then
+ 1. Let _status_ be _envRec_.CreateImmutableBinding(_dn_, *true*).
+ 1. Else,
+ 1. Let _status_ be _envRec_.CreateMutableBinding(_dn_, *false*).
+ 1. ReturnIfAbrupt(_status_).
+ 1. For each production _f_ in _functionsToInitialize_, do
+ 1. Let _fn_ be the sole element of the BoundNames of _f_.
+ 1. Let _fo_ be the result of performing InstantiateFunctionObject for _f_ with argument _env_.
+ 1. Let _status_ be ? _envRec_.CreateGlobalFunctionBinding(_fn_, _fo_, *false*).
+ 1. For each String _vn_ in _declaredVarNames_, in list order do
+ 1. Let _status_ be ? _envRec_.CreateGlobalVarBinding(_vn_, *false*).
+ 1. Return NormalCompletion(~empty~).
+
+
+
Early errors specified in prevent name conflicts between function/var declarations and let/const/class declarations as well as redeclaration of let/const/class bindings for declaration contained within a single |Script|. However, such conflicts and redeclarations that span more than one |Script| are detected as runtime errors during GlobalDeclarationInstantiation. If any such errors are detected, no bindings are instantiated for the script. However, if the global object is defined using Proxy exotic objects then the runtime tests for conflicting declarations may be unreliable resulting in an abrupt completion and some global declarations not being instantiated. If this occurs, the code for the |Script| is not evaluated.
+
Unlike explicit var or function declarations, properties that are directly created on the global object result in global bindings that may be shadowed by let/const/class declarations.
The job ScriptEvaluationJob with parameters _sourceText_ and _hostDefined_ parses, validates, and evaluates _sourceText_ as a |Script|.
+
+ 1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
+ 1. Let _realm_ be the running execution context's Realm.
+ 1. Let _s_ be ParseScript(_sourceText_, _hostDefined_).
+ 1. If _s_ is an abrupt completion, then
+ 1. Report or log the error(s) in an implementation dependent manner.
+ 1. NextJob NormalCompletion(*undefined*).
+ 1. Set _s_.[[Realm]] to _realm_.
+ 1. Let _status_ be the result of ScriptEvaluation of _s_ with argument _realm_.
+ 1. NextJob Completion(_status_).
+
+
+
+
+
+
+
+ It is a Syntax Error if the LexicallyDeclaredNames of |ModuleItemList| contains any duplicate entries.
+
+
+ It is a Syntax Error if any element of the LexicallyDeclaredNames of |ModuleItemList| also occurs in the VarDeclaredNames of |ModuleItemList|.
+
+
+ It is a Syntax Error if the ExportedNames of |ModuleItemList| contains any duplicate entries.
+
+
+ It is a Syntax Error if any element of the ExportedBindings of |ModuleItemList| does not also occur in either the VarDeclaredNames of |ModuleItemList|, or the LexicallyDeclaredNames of |ModuleItemList|.
+
+
+ It is a Syntax Error if |ModuleItemList| Contains `super`.
+
+
+ It is a Syntax Error if |ModuleItemList| Contains |NewTarget|
+
+
+ It is a Syntax Error if ContainsDuplicateLabels of |ModuleItemList| with argument « » is *true*.
+
+
+ It is a Syntax Error if ContainsUndefinedBreakTarget of |ModuleItemList| with argument « » is *true*.
+
+
+ It is a Syntax Error if ContainsUndefinedContinueTarget of |ModuleItemList| with arguments « » and « » is *true*.
+
+
+
+
The duplicate ExportedNames rule implies that multiple `export default` |ExportDeclaration| items within a |ModuleBody| is a Syntax Error. Additional error conditions relating to conflicting or duplicate declarations are checked during module linking prior to evaluation of a |Module|. If any such errors are detected the |Module| is not evaluated.
+
+
+
+
+
+
Static Semantics: ContainsDuplicateLabels
+
With argument _labelSet_.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _hasDuplicates_ be ContainsDuplicateLabels of |ModuleItemList| with argument _labelSet_.
+ 1. If _hasDuplicates_ is *true*, return *true*.
+ 1. Return ContainsDuplicateLabels of |ModuleItem| with argument _labelSet_.
+
+
+ ModuleItem :
+ ImportDeclaration
+ ExportDeclaration
+
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedBreakTarget
+
With argument _labelSet_.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedBreakTarget of |ModuleItemList| with argument _labelSet_.
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedBreakTarget of |ModuleItem| with argument _labelSet_.
+
+
+ ModuleItem :
+ ImportDeclaration
+ ExportDeclaration
+
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ContainsUndefinedContinueTarget
+
With arguments _iterationSet_ and _labelSet_.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _hasUndefinedLabels_ be ContainsUndefinedContinueTarget of |ModuleItemList| with arguments _iterationSet_ and « ».
+ 1. If _hasUndefinedLabels_ is *true*, return *true*.
+ 1. Return ContainsUndefinedContinueTarget of |ModuleItem| with arguments _iterationSet_ and « ».
+
+
+ ModuleItem :
+ ImportDeclaration
+ ExportDeclaration
+
+
+ 1. Return *false*.
+
+
+
+
+
+
Static Semantics: ExportedBindings
+
+
+
ExportedBindings are the locally bound names that are explicitly associated with a |Module|'s ExportedNames.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _names_ be ExportedBindings of |ModuleItemList|.
+ 1. Append to _names_ the elements of the ExportedBindings of |ModuleItem|.
+ 1. Return _names_.
+
+
+ ModuleItem :
+ ImportDeclaration
+ StatementListItem
+
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: ExportedNames
+
+
+
ExportedNames are the externally visible names that a |Module| explicitly maps to one of its local name bindings.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _names_ be ExportedNames of |ModuleItemList|.
+ 1. Append to _names_ the elements of the ExportedNames of |ModuleItem|.
+ 1. Return _names_.
+
+ ModuleItem : ExportDeclaration
+
+ 1. Return the ExportedNames of |ExportDeclaration|.
+
+
+ ModuleItem :
+ ImportDeclaration
+ StatementListItem
+
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: ExportEntries
+
+ Module : [empty]
+
+ 1. Return a new empty List.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _entries_ be ExportEntries of |ModuleItemList|.
+ 1. Append to _entries_ the elements of the ExportEntries of |ModuleItem|.
+ 1. Return _entries_.
+
+
+ ModuleItem :
+ ImportDeclaration
+ StatementListItem
+
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: ImportEntries
+
+ Module : [empty]
+
+ 1. Return a new empty List.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _entries_ be ImportEntries of |ModuleItemList|.
+ 1. Append to _entries_ the elements of the ImportEntries of |ModuleItem|.
+ 1. Return _entries_.
+
+
+ ModuleItem :
+ ExportDeclaration
+ StatementListItem
+
+
+ 1. Return a new empty List.
+
+
+
+
+
+
The abstract operation ImportedLocalNames with argument _importEntries_ creates a List of all of the local name bindings defined by a List of ImportEntry Records (see ). ImportedLocalNames performs the following steps:
+
+ 1. Let _localNames_ be a new empty List.
+ 1. For each ImportEntry Record _i_ in _importEntries_, do
+ 1. Append _i_.[[LocalName]] to _localNames_.
+ 1. Return _localNames_.
+
+
+
+
+
+
Static Semantics: ModuleRequests
+
+ Module : [empty]
+
+ 1. Return a new empty List.
+
+ ModuleItemList : ModuleItem
+
+ 1. Return ModuleRequests of |ModuleItem|.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _moduleNames_ be ModuleRequests of |ModuleItemList|.
+ 1. Let _additionalNames_ be ModuleRequests of |ModuleItem|.
+ 1. Append to _moduleNames_ each element of _additionalNames_ that is not already an element of _moduleNames_.
+ 1. Return _moduleNames_.
+
+ ModuleItem : StatementListItem
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: LexicallyDeclaredNames
+
+
+
The LexicallyDeclaredNames of a |Module| includes the names of all of its imported bindings.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _names_ be LexicallyDeclaredNames of |ModuleItemList|.
+ 1. Append to _names_ the elements of the LexicallyDeclaredNames of |ModuleItem|.
+ 1. Return _names_.
+
+ ModuleItem : ImportDeclaration
+
+ 1. Return the BoundNames of |ImportDeclaration|.
+
+ ModuleItem : ExportDeclaration
+
+ 1. If |ExportDeclaration| is `export` |VariableStatement|, return a new empty List.
+ 1. Return the BoundNames of |ExportDeclaration|.
+
+ ModuleItem : StatementListItem
+
+ 1. Return LexicallyDeclaredNames of |StatementListItem|.
+
+
+
At the top level of a |Module|, function declarations are treated like lexical declarations rather than like var declarations.
+
+
+
+
+
+
Static Semantics: LexicallyScopedDeclarations
+
+ Module : [empty]
+
+ 1. Return a new empty List.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _declarations_ be LexicallyScopedDeclarations of |ModuleItemList|.
+ 1. Append to _declarations_ the elements of the LexicallyScopedDeclarations of |ModuleItem|.
+ 1. Return _declarations_.
+
+ ModuleItem : ImportDeclaration
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: VarDeclaredNames
+
+ Module : [empty]
+
+ 1. Return an empty List.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _names_ be VarDeclaredNames of |ModuleItemList|.
+ 1. Append to _names_ the elements of the VarDeclaredNames of |ModuleItem|.
+ 1. Return _names_.
+
+ ModuleItem : ImportDeclaration
+
+ 1. Return an empty List.
+
+ ModuleItem : ExportDeclaration
+
+ 1. If |ExportDeclaration| is `export` |VariableStatement|, return BoundNames of |ExportDeclaration|.
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: VarScopedDeclarations
+
+ Module : [empty]
+
+ 1. Return a new empty List.
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _declarations_ be VarScopedDeclarations of |ModuleItemList|.
+ 1. Append to _declarations_ the elements of the VarScopedDeclarations of |ModuleItem|.
+ 1. Return _declarations_.
+
+ ModuleItem : ImportDeclaration
+
+ 1. Return a new empty List.
+
+ ModuleItem : ExportDeclaration
+
+ 1. If |ExportDeclaration| is `export` |VariableStatement|, return VarScopedDeclarations of |VariableStatement|.
+ 1. Return a new empty List.
+
+
+
+
+
+
Abstract Module Records
+
A Module Record encapsulates structural information about the imports and exports of a single module. This information is used to link the imports and exports of sets of connected modules. A Module Record includes four fields that are only used when evaluating a module.
+
For specification purposes Module Record values are values of the Record specification type and can be thought of as existing in a simple object-oriented hierarchy where Module Record is an abstract class with concrete subclasses. This specification only defines a single Module Record concrete subclass named Source Text Module Record. Other specifications and implementations may define additional Module Record subclasses corresponding to alternative module definition facilities that they defined.
+
Module Record defines the fields listed in . All Module Definition subclasses include at least those fields. Module Record also defines the abstract method list in . All Module definition subclasses must provide concrete implementations of these abstract methods.
+
+
+
+
+
+ Field Name
+
+
+ Value Type
+
+
+ Meaning
+
+
+
+
+
+
+ [[Realm]]
+
+
+ Realm Record | *undefined*
+
+
+ The Realm within which this module was created. *undefined* if not yet assigned.
+
+
+
+
+ [[Environment]]
+
+
+ Lexical Environment | *undefined*
+
+
+ The Lexical Environment containing the top level bindings for this module. This field is set when the module is instantiated.
+
+
+
+
+ [[Namespace]]
+
+
+ Object | *undefined*
+
+
+ The Module Namespace Object () if one has been created for this module. Otherwise *undefined*.
+
+
+
+
+ [[Evaluated]]
+
+
+ Boolean
+
+
+ Initially *false*, *true* if evaluation of this module has started. Remains *true* when evaluation completes, even if it is an abrupt completion.
+
+
+
+
+ [[HostDefined]]
+
+
+ Any, default value is *undefined*.
+
+
+ Field reserved for use by host environments that need to associate additional information with a module.
+
+
+
+
+
+
+
+
+
+
+ Method
+
+
+ Purpose
+
+
+
+
+ GetExportedNames(exportStarSet)
+
+
+ Return a list of all names that are either directly or indirectly exported from this module.
+
+ Return the binding of a name exported by this modules. Bindings are represented by a Record of the form {[[module]]: Module Record, [[bindingName]]: String}
+
+
+
+
+ ModuleDeclarationInstantiation()
+
+
+ Transitively resolve all module dependencies and create a module Environment Record for the module.
+
+
+
+
+ ModuleEvaluation()
+
+
+
Do nothing if this module has already been evaluated. Otherwise, transitively evaluate all module dependences of this module and then evaluate this module.
+
ModuleDeclarationInstantiation must be completed prior to invoking this method.
+
+
+
+
+
+
+
+
+
+
Source Text Module Records
+
A Source Text Module Record is used to represent information about a module that was defined from ECMAScript source text (10) that was parsed using the goal symbol |Module|. Its fields contain digested information about the names that are imported by the module and its concrete methods use this digest to link, instantiate, and evaluate the module.
+
In addition to the fields, defined in , Source Text Module Records have the additional fields listed in . Each of these fields initially has the value *undefined*.
+
+
+
+
+
+ Field Name
+
+
+ Value Type
+
+
+ Meaning
+
+
+
+
+ [[ECMAScriptCode]]
+
+
+ a parse result
+
+
+ The result of parsing the source text of this module using |Module| as the goal symbol.
+
+
+
+
+ [[RequestedModules]]
+
+
+ List of String
+
+
+ A List of all the |ModuleSpecifier| strings used by the module represented by this record to request the importation of a module. The List is source code occurrence ordered.
+
+
+
+
+ [[ImportEntries]]
+
+
+ List of ImportEntry Records
+
+
+ A List of ImportEntry records derived from the code of this module.
+
+
+
+
+ [[LocalExportEntries]]
+
+
+ List of ExportEntry Records
+
+
+ A List of ExportEntry records derived from the code of this module that correspond to declarations that occur within the module.
+
+
+
+
+ [[IndirectExportEntries]]
+
+
+ List of ExportEntry Records
+
+
+ A List of ExportEntry records derived from the code of this module that correspond to reexported imports that occur within the module.
+
+
+
+
+ [[StarExportEntries]]
+
+
+ List of ExportEntry Records
+
+
+ A List of ExportEntry records derived from the code of this module that correspond to export * declarations that occur within the module.
+
+
+
+
+
+
An ImportEntry Record is a Record that digests information about a single declarative import. Each ImportEntry Record has the fields defined in :
+
+
+
+
+
+ Field Name
+
+
+ Value Type
+
+
+ Meaning
+
+
+
+
+ [[ModuleRequest]]
+
+
+ String
+
+
+ String value of the |ModuleSpecifier| of the |ImportDeclaration|.
+
+
+
+
+ [[ImportName]]
+
+
+ String
+
+
+ The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. The value `"*"` indicates that the import request is for the target module's namespace object.
+
+
+
+
+ [[LocalName]]
+
+
+ String
+
+
+ The name that is used to locally access the imported value from within the importing module.
+
+
+
+
+
+
+
gives examples of ImportEntry records fields used to represent the syntactic import forms:
+
+
+
+
+
+ Import Statement Form
+
+
+ [[ModuleRequest]]
+
+
+ [[ImportName]]
+
+
+ [[LocalName]]
+
+
+
+
+ `import v from "mod";`
+
+
+ `"mod"`
+
+
+ `"default"`
+
+
+ `"v"`
+
+
+
+
+ `import * as ns from "mod";`
+
+
+ `"mod"`
+
+
+ `"*"`
+
+
+ `"ns"`
+
+
+
+
+ `import {x} from "mod";`
+
+
+ `"mod"`
+
+
+ `"x"`
+
+
+ `"x"`
+
+
+
+
+ `import {x as v} from "mod";`
+
+
+ `"mod"`
+
+
+ `"x"`
+
+
+ `"v"`
+
+
+
+
+ `import "mod";`
+
+
+ An ImportEntry Record is not created.
+
+
+
+
+
+
+
An ExportEntry Record is a Record that digests information about a single declarative export. Each ExportEntry Record has the fields defined in :
+
+
+
+
+
+ Field Name
+
+
+ Value Type
+
+
+ Meaning
+
+
+
+
+ [[ExportName]]
+
+
+ String
+
+
+ The name used to export this binding by this module.
+
+
+
+
+ [[ModuleRequest]]
+
+
+ String | null
+
+
+ The String value of the |ModuleSpecifier| of the |ExportDeclaration|. *null* if the |ExportDeclaration| does not have a |ModuleSpecifier|.
+
+
+
+
+ [[ImportName]]
+
+
+ String | null
+
+
+ The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. *null* if the |ExportDeclaration| does not have a |ModuleSpecifier|. `"*"` indicates that the export request is for all exported bindings.
+
+
+
+
+ [[LocalName]]
+
+
+ String | null
+
+
+ The name that is used to locally access the exported value from within the importing module. *null* if the exported value is not locally accessible from within the module.
+
+
+
+
+
+
+
gives examples of the ExportEntry record fields used to represent the syntactic export forms:
+
+
+
+
+
+ Export Statement Form
+
+
+ [[ExportName]]
+
+
+ [[ModuleRequest]]
+
+
+ [[ImportName]]
+
+
+ [[LocalName]]
+
+
+
+
+ `export var v;`
+
+
+ `"v"`
+
+
+ *null*
+
+
+ *null*
+
+
+ `"v"`
+
+
+
+
+ `export default function f(){};`
+
+
+ `"default"`
+
+
+ *null*
+
+
+ *null*
+
+
+ `"f"`
+
+
+
+
+ `export default function(){};`
+
+
+ `"default"`
+
+
+ *null*
+
+
+ *null*
+
+
+ `"*default*"`
+
+
+
+
+ `export default 42;`
+
+
+ `"default"`
+
+
+ *null*
+
+
+ *null*
+
+
+ `"*default*"`
+
+
+
+
+ `export {x};`
+
+
+ `"x"`
+
+
+ *null*
+
+
+ *null*
+
+
+ `"x"`
+
+
+
+
+ `export {v as x};`
+
+
+ `"x"`
+
+
+ *null*
+
+
+ *null*
+
+
+ `"v"`
+
+
+
+
+ `export {x} from "mod";`
+
+
+ `"x"`
+
+
+ `"mod"`
+
+
+ `"x"`
+
+
+ *null*
+
+
+
+
+ `export {v as x} from "mod";`
+
+
+ `"x"`
+
+
+ `"mod"`
+
+
+ `"v"`
+
+
+ *null*
+
+
+
+
+ `export * from "mod";`
+
+
+ *null*
+
+
+ `"mod"`
+
+
+ `"*"`
+
+
+ *null*
+
+
+
+
+
+
+
The following definitions specify the required concrete methods and other abstract operations for Source Text Module Records
+
+
+
+
ParseModule ( _sourceText_, _hostDefined_ )
+
The abstract operation ParseModule with arguments _sourceText_ and _hostDefined_ creates a Source Text Module Record based upon the result of parsing _sourceText_ as a |Module|. ParseModule performs the following steps:
+
+ 1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
+ 1. Parse _sourceText_ using |Module| as the goal symbol and analyze the parse result for any Early Error conditions. If the parse was successful and no early errors were found, let _body_ be the resulting parse tree. Otherwise, let _body_ be an indication of one or more parsing errors and/or early errors. Parsing and early error detection may be interweaved in an implementation dependent manner. If more than one parse or early error is present, the number and ordering of reported errors is implementation dependent but at least one error must be reported.
+ 1. If _body_ is an abrupt completion or error indication, then
+ 1. Throw a *SyntaxError* exception.
+ 1. Let _requestedModules_ be the ModuleRequests of _body_.
+ 1. Let _importEntries_ be ImportEntries of _body_.
+ 1. Let _importedBoundNames_ be ImportedLocalNames(_importEntries_).
+ 1. Let _indirectExportEntries_ be a new empty List.
+ 1. Let _localExportEntries_ be a new empty List.
+ 1. Let _starExportEntries_ be a new empty List.
+ 1. Let _exportEntries_ be ExportEntries of _body_.
+ 1. For each record _ee_ in _exportEntries_, do
+ 1. If _ee_.[[ModuleRequest]] is *null*, then
+ 1. If _ee_.[[LocalName]] is not an element of _importedBoundNames_, then
+ 1. Append _ee_ to _localExportEntries_.
+ 1. Else,
+ 1. Let _ie_ be the element of _importEntries_ whose [[LocalName]] is the same as _ee_.[[LocalName]].
+ 1. If _ie_.[[ImportName]] is `"*"`, then
+ 1. Assert: this is a re-export of an imported module namespace object.
+ 1. Append _ee_ to _localExportEntries_.
+ 1. Else, this is a re-export of a single name
+ 1. Append to _indirectExportEntries_ the Record {[[ModuleRequest]]: _ie_.[[ModuleRequest]], [[ImportName]]: _ie_.[[ImportName]], [[LocalName]]: *null*, [[ExportName]]: _ee_.[[ExportName]] }.
+ 1. Else, if _ee_.[[ImportName]] is `"*"`, then
+ 1. Append _ee_ to _starExportEntries_.
+ 1. Else,
+ 1. Append _ee_ to _indirectExportEntries_.
+ 1. Return Source Text Module Record {[[Realm]]: *undefined*, [[Environment]]: *undefined*, [[HostDefined]]: _hostDefined_, [[Namespace]]: *undefined*, [[Evaluated]]: *false*, [[ECMAScriptCode]]: _body_, [[RequestedModules]]: _requestedModules_, [[ImportEntries]]: _importEntries_, [[LocalExportEntries]]: _localExportEntries_, [[StarExportEntries]]: _starExportEntries_, [[IndirectExportEntries]]: _indirectExportEntries_}.
+
+
+
An implementation may parse module source text and analyze it for Early Error conditions prior to the evaluation of ParseModule for that module source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that source text.
The GetExportedNames concrete method of a Source Text Module Record with argument _exportStarSet_ performs the following steps:
+
+ 1. Let _module_ be this Source Text Module Record.
+ 1. If _exportStarSet_ contains _module_, then
+ 1. Assert: We've reached the starting point of an import * circularity.
+ 1. Return a new empty List.
+ 1. Append _module_ to _exportStarSet_.
+ 1. Let _exportedNames_ be a new empty List.
+ 1. For each ExportEntry Record _e_ in _module_.[[LocalExportEntries]], do
+ 1. Assert: _module_ provides the direct binding for this export.
+ 1. Append _e_.[[ExportName]] to _exportedNames_.
+ 1. For each ExportEntry Record _e_ in _module_.[[IndirectExportEntries]], do
+ 1. Assert: _module_ imports a specific binding for this export.
+ 1. Append _e_.[[ExportName]] to _exportedNames_.
+ 1. For each ExportEntry Record _e_ in _module_.[[StarExportEntries]], do
+ 1. Let _requestedModule_ be ? HostResolveImportedModule(_module_, _e_.[[ModuleRequest]]).
+ 1. Let _starNames_ be _requestedModule_.GetExportedNames(_exportStarSet_).
+ 1. For each element _n_ of _starNames_, do
+ 1. If SameValue(_n_, `"default"`) is *false*, then
+ 1. If _n_ is not an element of _exportedNames_, then
+ 1. Append _n_ to _exportedNames_.
+ 1. Return _exportedNames_.
+
+
+
GetExportedNames does not filter out or throw an exception for names that have ambiguous star export bindings.
The ResolveExport concrete method of a Source Text Module Record with arguments _exportName_, _resolveSet_, and _exportStarSet_ performs the following steps:
+
+ 1. Let _module_ be this Source Text Module Record.
+ 1. For each Record {[[module]], [[exportName]]} _r_ in _resolveSet_, do:
+ 1. If _module_ and _r_.[[module]] are the same Module Record and SameValue(_exportName_, _r_.[[exportName]]) is *true*, then
+ 1. Assert: this is a circular import request.
+ 1. Return *null*.
+ 1. Append the Record {[[module]]: _module_, [[exportName]]: _exportName_} to _resolveSet_.
+ 1. For each ExportEntry Record _e_ in _module_.[[LocalExportEntries]], do
+ 1. If SameValue(_exportName_, _e_.[[ExportName]]) is *true*, then
+ 1. Assert: _module_ provides the direct binding for this export.
+ 1. Return Record{[[module]]: _module_, [[bindingName]]: _e_.[[LocalName]]}.
+ 1. For each ExportEntry Record _e_ in _module_.[[IndirectExportEntries]], do
+ 1. If SameValue(_exportName_, _e_.[[ExportName]]) is *true*, then
+ 1. Assert: _module_ imports a specific binding for this export.
+ 1. Let _importedModule_ be ? HostResolveImportedModule(_module_, _e_.[[ModuleRequest]]).
+ 1. Let _indirectResolution_ be ? _importedModule_.ResolveExport(_e_.[[ImportName]], _resolveSet_, _exportStarSet_).
+ 1. If _indirectResolution_ is not *null*, return _indirectResolution_.
+ 1. If SameValue(_exportName_, `"default"`) is *true*, then
+ 1. Assert: A `default` export was not explicitly defined by this module.
+ 1. Throw a *SyntaxError* exception.
+ 1. NOTE A `default` export cannot be provided by an `export *`.
+ 1. If _exportStarSet_ contains _module_, return *null*.
+ 1. Append _module_ to _exportStarSet_.
+ 1. Let _starResolution_ be *null*.
+ 1. For each ExportEntry Record _e_ in _module_.[[StarExportEntries]], do
+ 1. Let _importedModule_ be ? HostResolveImportedModule(_module_, _e_.[[ModuleRequest]]).
+ 1. Let _resolution_ be ? _importedModule_.ResolveExport(_exportName_, _resolveSet_, _exportStarSet_).
+ 1. If _resolution_ is `"ambiguous"`, return `"ambiguous"`.
+ 1. If _resolution_ is not *null*, then
+ 1. If _starResolution_ is *null*, let _starResolution_ be _resolution_.
+ 1. Else,
+ 1. Assert: there is more than one * import that includes the requested name.
+ 1. If _resolution_.[[module]] and _starResolution_.[[module]] are not the same Module Record or SameValue(_resolution_.[[bindingName]], _starResolution_.[[bindingName]]) is *false*, return `"ambiguous"`.
+ 1. Return _starResolution_.
+
+
+
ResolveExport attempts to resolve an imported binding to the actual defining module and local binding name. The defining module may be the module represented by the Module Record this method was invoked on or some other module that is imported by that module. The parameter _resolveSet_ is use to detect unresolved circular import/export paths. If a pair consisting of specific Module Record and _exportName_ is reached that is already in _resolveSet_, an import circularity has been encountered. Before recursively calling ResolveExport, a pair consisting of _module_ and _exportName_ is added to _resolveSet_.
+
If a defining module is found a Record {[[module]], [[bindingName]]} is returned. This record identifies the resolved binding of the originally requested export. If no definition was found or the request is found to be circular, *null* is returned. If the request is found to be ambiguous, the string `"ambiguous"` is returned.
+
+
+
+
+
+
ModuleDeclarationInstantiation( ) Concrete Method
+
The ModuleDeclarationInstantiation concrete method of a Source Text Module Record performs the following steps:
+
+ 1. Let _module_ be this Source Text Module Record.
+ 1. Let _realm_ be _module_.[[Realm]].
+ 1. Assert: _realm_ is not *undefined*.
+ 1. Let _code_ be _module_.[[ECMAScriptCode]].
+ 1. If _module_.[[Environment]] is not *undefined*, return NormalCompletion(~empty~).
+ 1. Let _env_ be NewModuleEnvironment(_realm_.[[globalEnv]]).
+ 1. Set _module_.[[Environment]] to _env_.
+ 1. For each String _required_ that is an element of _module_.[[RequestedModules]] do,
+ 1. NOTE: Before instantiating a module, all of the modules it requested must be available. An implementation may perform this test at any time prior to this point,
+ 1. Let _requiredModule_ be ? HostResolveImportedModule(_module_, _required_).
+ 1. Let _status_ be ? _requiredModule_.ModuleDeclarationInstantiation().
+ 1. For each ExportEntry Record _e_ in _module_.[[IndirectExportEntries]], do
+ 1. Let _resolution_ be ? _module_.ResolveExport(_e_.[[ExportName]], « », « »).
+ 1. If _resolution_ is *null* or _resolution_ is `"ambiguous"`, throw a *SyntaxError* exception.
+ 1. Assert: all named exports from _module_ are resolvable.
+ 1. Let _envRec_ be _env_'s EnvironmentRecord.
+ 1. For each ImportEntry Record _in_ in _module_.[[ImportEntries]], do
+ 1. Let _importedModule_ be ? HostResolveImportedModule(_module_, _in_.[[ModuleRequest]]).
+ 1. If _in_.[[ImportName]] is `"*"`, then
+ 1. Let _namespace_ be ? GetModuleNamespace(_importedModule_).
+ 1. Let _status_ be _envRec_.CreateImmutableBinding(_in_.[[LocalName]], *true*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Call _envRec_.InitializeBinding(_in_.[[LocalName]], _namespace_).
+ 1. Else,
+ 1. Let _resolution_ be ? _importedModule_.ResolveExport(_in_.[[ImportName]], « », « »).
+ 1. If _resolution_ is *null* or _resolution_ is `"ambiguous"`, throw a *SyntaxError* exception.
+ 1. Call _envRec_.CreateImportBinding(_in_.[[LocalName]], _resolution_.[[module]], _resolution_.[[bindingName]]).
+ 1. Let _varDeclarations_ be the VarScopedDeclarations of _code_.
+ 1. Let _declaredVarNames_ be an empty List.
+ 1. For each element _d_ in _varDeclarations_ do
+ 1. For each element _dn_ of the BoundNames of _d_ do
+ 1. If _dn_ is not an element of _declaredVarNames_, then
+ 1. Let _status_ be _envRec_.CreateMutableBinding(_dn_, *false*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Call _envRec_.InitializeBinding(_dn_, *undefined*).
+ 1. Append _dn_ to _declaredVarNames_.
+ 1. Let _lexDeclarations_ be the LexicallyScopedDeclarations of _code_.
+ 1. For each element _d_ in _lexDeclarations_ do
+ 1. For each element _dn_ of the BoundNames of _d_ do
+ 1. If IsConstantDeclaration of _d_ is *true*, then
+ 1. Let _status_ be _envRec_.CreateImmutableBinding(_dn_, *true*).
+ 1. Else,
+ 1. Let _status_ be _envRec_.CreateMutableBinding(_dn_, *false*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. If _d_ is a |GeneratorDeclaration| production or a |FunctionDeclaration| production, then
+ 1. Let _fo_ be the result of performing InstantiateFunctionObject for _d_ with argument _env_.
+ 1. Call _envRec_.InitializeBinding(_dn_, _fo_).
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
ModuleEvaluation() Concrete Method
+
The ModuleEvaluation concrete method of a Source Text Module Record performs the following steps:
+
+ 1. Let _module_ be this Source Text Module Record.
+ 1. Assert: ModuleDeclarationInstantiation has already been invoked on _module_ and successfully completed.
+ 1. Assert: _module_.[[Realm]] is not *undefined*.
+ 1. If _module_.[[Evaluated]] is *true*, return *undefined*.
+ 1. Set _module_.[[Evaluated]] to *true*.
+ 1. For each String _required_ that is an element of _module_.[[RequestedModules]] do,
+ 1. Let _requiredModule_ be ? HostResolveImportedModule(_module_, _required_).
+ 1. Let _status_ be ? _requiredModule_.ModuleEvaluation().
+ 1. Let _moduleCxt_ be a new ECMAScript code execution context.
+ 1. Set the Function of _moduleCxt_ to *null*.
+ 1. Set the Realm of _moduleCxt_ to _module_.[[Realm]].
+ 1. Set the ScriptOrModule of _moduleCxt_ to _module_.
+ 1. Assert: _module_ has been linked and declarations in its module environment have been instantiated.
+ 1. Set the VariableEnvironment of _moduleCxt_ to _module_.[[Environment]].
+ 1. Set the LexicalEnvironment of _moduleCxt_ to _module_.[[Environment]].
+ 1. Suspend the currently running execution context.
+ 1. Push _moduleCxt_ on to the execution context stack; _moduleCxt_ is now the running execution context.
+ 1. Let _result_ be the result of evaluating _module_.[[ECMAScriptCode]].
+ 1. Suspend _moduleCxt_ and remove it from the execution context stack.
+ 1. Resume the context that is now on the top of the execution context stack as the running execution context.
+ 1. Return Completion(_result_).
+
+
+
+
+
+
+
HostResolveImportedModule is an implementation defined abstract operation that provides the concrete Module Record subclass instance that corresponds to the |ModuleSpecifier| String, _specifier_, occurring within the context of the module represented by the Module Record _referencingModule_.
+
The implementation of HostResolveImportedModule must conform to the following requirements:
+
+
+ The normal return value must be an instance of a concrete subclass of Module Record.
+
+
+ If a Module Record corresponding to the pair _referencingModule_, _specifier_ does not exist or cannot be created, an exception must be thrown.
+
+
+ This operation must be idempotent if it completes normally. Each time it is called with a specific _referencingModule_, _specifier_ pair as arguments it must return the same Module Record instance.
+
+
+
Multiple different _referencingModule_, _specifier_ pairs may map to the same Module Record instance. The actual mapping semantic is implementation defined but typically a normalization process is applied to _specifier_ as part of the mapping process. A typical normalization process would include actions such as alphabetic case folding and expansion of relative and abbreviated path specifiers.
+
+
+
+
+
Runtime Semantics: GetModuleNamespace( _module_ )
+
The abstract operation GetModuleNamespace called with argument _module_ performs the following steps:
+
+ 1. Assert: _module_ is an instance of a concrete subclass of Module Record.
+ 1. Let _namespace_ be _module_.[[Namespace]].
+ 1. If _namespace_ is *undefined*, then
+ 1. Let _exportedNames_ be ? _module_.GetExportedNames(« »).
+ 1. Let _unambiguousNames_ be a new empty List.
+ 1. For each _name_ that is an element of _exportedNames_,
+ 1. Let _resolution_ be ? _module_.ResolveExport(_name_, « », « »).
+ 1. If _resolution_ is *null*, throw a *SyntaxError* exception.
+ 1. If _resolution_ is not `"ambiguous"`, append _name_ to _unambiguousNames_.
+ 1. Let _namespace_ be ModuleNamespaceCreate(_module_, _unambiguousNames_).
+ 1. Return _namespace_.
+
+
+
+
+
+
A TopLevelModuleEvaluationJob with parameters _sourceText_ and _hostDefined_ is a job that parses, validates, and evaluates _sourceText_ as a |Module|.
+
+ 1. Assert: _sourceText_ is an ECMAScript source text (see clause ).
+ 1. Let _realm_ be the running execution context's Realm.
+ 1. Let _m_ be ParseModule(_sourceText_, _hostDefined_).
+ 1. If _m_ is an abrupt completion, then
+ 1. Report or log the error(s) in an implementation dependent manner.
+ 1. NextJob NormalCompletion(*undefined*).
+ 1. Set _m_.[[Realm]] to _realm_.
+ 1. Let _status_ be _m_.ModuleDeclarationInstantiation().
+ 1. If _status_ is not an abrupt completion, then
+ 1. Assert: all dependencies of _m_ have been transitively resolved and _m_ is ready for evaluation.
+ 1. Let _status_ be _m_.ModuleEvaluation().
+ 1. NextJob Completion(_status_).
+
+
+
An implementation may parse a _sourceText_ as a |Module|, analyze it for Early Error conditions, and instantiate it prior to the execution of the TopLevelModuleEvaluationJob for that _sourceText_. An implementation may also resolve, pre-parse and pre-analyze, and pre-instantiate module dependencies of _sourceText_. However, the reporting of any errors detected by these actions must be deferred until the TopLevelModuleEvaluationJob is actually executed.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+ Module : [empty]
+
+ 1. Return NormalCompletion(*undefined*).
+
+ ModuleBody : ModuleItemList
+
+ 1. Let _result_ be the result of evaluating |ModuleItemList|.
+ 1. If _result_.[[type]] is ~normal~ and _result_.[[value]] is ~empty~, then
+ 1. Return NormalCompletion(*undefined*).
+ 1. Return Completion(_result_).
+
+ ModuleItemList : ModuleItemList ModuleItem
+
+ 1. Let _sl_ be the result of evaluating |ModuleItemList|.
+ 1. ReturnIfAbrupt(_sl_).
+ 1. Let _s_ be the result of evaluating |ModuleItem|.
+ 1. Return Completion(UpdateEmpty(_s_, _sl_.[[value]])).
+
+
+
The value of a |ModuleItemList| is the value of the last value producing item in the |ModuleItemList|.
+ It is a Syntax Error if the BoundNames of |ImportDeclaration| contains any duplicate entries.
+
+
+
+
+
+
+
Static Semantics: BoundNames
+
+ ImportDeclaration : `import` ImportClause FromClause `;`
+
+ 1. Return the BoundNames of |ImportClause|.
+
+ ImportDeclaration : `import` ModuleSpecifier `;`
+
+ 1. Return a new empty List.
+
+ ImportClause : ImportedDefaultBinding `,` NameSpaceImport
+
+ 1. Let _names_ be the BoundNames of |ImportedDefaultBinding|.
+ 1. Append to _names_ the elements of the BoundNames of |NameSpaceImport|.
+ 1. Return _names_.
+
+ ImportClause : ImportedDefaultBinding `,` NamedImports
+
+ 1. Let _names_ be the BoundNames of |ImportedDefaultBinding|.
+ 1. Append to _names_ the elements of the BoundNames of |NamedImports|.
+ 1. Return _names_.
+
+ NamedImports : `{` `}`
+
+ 1. Return a new empty List.
+
+ ImportsList : ImportsList `,` ImportSpecifier
+
+ 1. Let _names_ be the BoundNames of |ImportsList|.
+ 1. Append to _names_ the elements of the BoundNames of |ImportSpecifier|.
+ 1. Return _names_.
+
+ ImportSpecifier : IdentifierName `as` ImportedBinding
+
+ 1. Return the BoundNames of |ImportedBinding|.
+
+
+
+
+
+
Static Semantics: ImportEntries
+
+ ImportDeclaration : `import` ImportClause FromClause `;`
+
+ 1. Let _module_ be the sole element of ModuleRequests of |FromClause|.
+ 1. Return ImportEntriesForModule of |ImportClause| with argument _module_.
+
+ ImportDeclaration : `import` ModuleSpecifier `;`
+
+ 1. Return a new empty List.
+
+
+
+
+
+
Static Semantics: ImportEntriesForModule
+
With parameter _module_.
+ ImportClause : ImportedDefaultBinding `,` NameSpaceImport
+
+ 1. Let _entries_ be ImportEntriesForModule of |ImportedDefaultBinding| with argument _module_.
+ 1. Append to _entries_ the elements of the ImportEntriesForModule of |NameSpaceImport| with argument _module_.
+ 1. Return _entries_.
+
+ ImportClause : ImportedDefaultBinding `,` NamedImports
+
+ 1. Let _entries_ be ImportEntriesForModule of |ImportedDefaultBinding| with argument _module_.
+ 1. Append to _entries_ the elements of the ImportEntriesForModule of |NamedImports| with argument _module_.
+ 1. Return _entries_.
+
+ ImportedDefaultBinding : ImportedBinding
+
+ 1. Let _localName_ be the sole element of BoundNames of |ImportedBinding|.
+ 1. Let _defaultEntry_ be the Record {[[ModuleRequest]]: _module_, [[ImportName]]: `"default"`, [[LocalName]]: _localName_ }.
+ 1. Return a new List containing _defaultEntry_.
+
+ NameSpaceImport : `*` `as` ImportedBinding
+
+ 1. Let _localName_ be the StringValue of |ImportedBinding|.
+ 1. Let _entry_ be the Record {[[ModuleRequest]]: _module_, [[ImportName]]: `"*"`, [[LocalName]]: _localName_ }.
+ 1. Return a new List containing _entry_.
+
+ NamedImports : `{` `}`
+
+ 1. Return a new empty List.
+
+ ImportsList : ImportsList `,` ImportSpecifier
+
+ 1. Let _specs_ be the ImportEntriesForModule of |ImportsList| with argument _module_.
+ 1. Append to _specs_ the elements of the ImportEntriesForModule of |ImportSpecifier| with argument _module_.
+ 1. Return _specs_.
+
+ ImportSpecifier : ImportedBinding
+
+ 1. Let _localName_ be the sole element of BoundNames of |ImportedBinding|.
+ 1. Let _entry_ be the Record {[[ModuleRequest]]: _module_, [[ImportName]]: _localName_ , [[LocalName]]: _localName_ }.
+ 1. Return a new List containing _entry_.
+
+ ImportSpecifier : IdentifierName `as` ImportedBinding
+
+ 1. Let _importName_ be the StringValue of |IdentifierName|.
+ 1. Let _localName_ be the StringValue of |ImportedBinding|.
+ 1. Let _entry_ be the Record {[[ModuleRequest]]: _module_, [[ImportName]]: _importName_, [[LocalName]]: _localName_ }.
+ 1. Return a new List containing _entry_.
+
+
+
+
+
+
Static Semantics: ModuleRequests
+
+ ImportDeclaration : `import` ImportClause FromClause `;`
+
+ 1. Return ModuleRequests of |FromClause|.
+
+ ModuleSpecifier : StringLiteral
+
+ 1. Return a List containing the StringValue of |StringLiteral|.
+
+
+
+
+
+
+
+ For each |IdentifierName| _n_ in ReferencedBindings of |ExportClause|: It is a Syntax Error if StringValue of _n_ is a |ReservedWord| or if the StringValue of _n_ is one of: `"implements"`, `"interface"`, `"let"`, `"package"`, `"private"`, `"protected"`, `"public"`, or `"static"`.
+
+
+
+
The above rule means that each ReferencedBindings of |ExportClause| is treated as an |IdentifierReference|.
+
+
+
+
+
+
Static Semantics: BoundNames
+
+
+ ExportDeclaration :
+ `export` `*` FromClause `;`
+ `export` ExportClause FromClause `;`
+ `export` ExportClause `;`
+
+
+ 1. Return a new empty List.
+
+ ExportDeclaration : `export` VariableStatement
+
+ 1. Return the BoundNames of |VariableStatement|.
+
+ ExportDeclaration : `export` Declaration
+
+ 1. Return the BoundNames of |Declaration|.
+
+ ExportDeclaration : `export` `default` HoistableDeclaration
+
+ 1. Let _declarationNames_ be the BoundNames of |HoistableDeclaration|.
+ 1. If _declarationNames_ does not include the element `"*default*"`, append `"*default*"` to _declarationNames_.
+ 1. Return _declarationNames_.
+
+ ExportDeclaration : `export` `default` ClassDeclaration
+
+ 1. Let _declarationNames_ be the BoundNames of |ClassDeclaration|.
+ 1. If _declarationNames_ does not include the element `"*default*"`, append `"*default*"` to _declarationNames_.
+ 1. Return _declarationNames_.
+
+ ExportDeclaration : `export` `default` AssignmentExpression `;`
+
+ 1. Return « `"*default*"` ».
+
+
+
+
+
+
Static Semantics: ExportedBindings
+
+
+ ExportDeclaration :
+ `export` ExportClause FromClause `;`
+ `export` `*` FromClause `;`
+
+
+ 1. Return a new empty List.
+
+ ExportDeclaration : `export` ExportClause `;`
+
+ 1. Return the ExportedBindings of |ExportClause|.
+
+ ExportDeclaration : `export` VariableStatement
+
+ 1. Return the BoundNames of |VariableStatement|.
+
+ ExportDeclaration : `export` Declaration
+
+ 1. Return the BoundNames of |Declaration|.
+
+
+ ExportDeclaration : `export` `default` HoistableDeclaration
+
+ ExportDeclaration : `export` `default` ClassDeclaration
+
+ ExportDeclaration : `export` `default` AssignmentExpression `;`
+
+
+ 1. Return the BoundNames of this |ExportDeclaration|.
+
+ ExportClause : `{` `}`
+
+ 1. Return a new empty List.
+
+ ExportsList : ExportsList `,` ExportSpecifier
+
+ 1. Let _names_ be the ExportedBindings of |ExportsList|.
+ 1. Append to _names_ the elements of the ExportedBindings of |ExportSpecifier|.
+ 1. Return _names_.
+
+ ExportSpecifier : IdentifierName
+
+ 1. Return a List containing the StringValue of |IdentifierName|.
+
+ ExportSpecifier : IdentifierName `as` IdentifierName
+
+ 1. Return a List containing the StringValue of the first |IdentifierName|.
+
+
+
+
+
+
Static Semantics: ExportedNames
+
+ ExportDeclaration : `export` `*` FromClause `;`
+
+ 1. Return a new empty List.
+
+
+ ExportDeclaration :
+ `export` ExportClause FromClause `;`
+ `export` ExportClause `;`
+
+
+ 1. Return the ExportedNames of |ExportClause|.
+
+ ExportDeclaration : `export` VariableStatement
+
+ 1. Return the BoundNames of |VariableStatement|.
+
+ ExportDeclaration : `export` Declaration
+
+ 1. Return the BoundNames of |Declaration|.
+
+
+ ExportDeclaration : `export` `default` HoistableDeclaration
+
+ ExportDeclaration : `export` `default` ClassDeclaration
+
+ ExportDeclaration : `export` `default` AssignmentExpression `;`
+
+
+ 1. Return « `"default"` ».
+
+ ExportClause : `{` `}`
+
+ 1. Return a new empty List.
+
+ ExportsList : ExportsList `,` ExportSpecifier
+
+ 1. Let _names_ be the ExportedNames of |ExportsList|.
+ 1. Append to _names_ the elements of the ExportedNames of |ExportSpecifier|.
+ 1. Return _names_.
+
+ ExportSpecifier : IdentifierName
+
+ 1. Return a List containing the StringValue of |IdentifierName|.
+
+ ExportSpecifier : IdentifierName `as` IdentifierName
+
+ 1. Return a List containing the StringValue of the second |IdentifierName|.
+
+
+
+
+
+
Static Semantics: ExportEntries
+
+ ExportDeclaration : `export` `*` FromClause `;`
+
+ 1. Let _module_ be the sole element of ModuleRequests of |FromClause|.
+ 1. Let _entry_ be the Record {[[ModuleRequest]]: _module_, [[ImportName]]: `"*"`, [[LocalName]]: *null*, [[ExportName]]: *null* }.
+ 1. Return a new List containing _entry_.
+
+ ExportDeclaration : `export` ExportClause FromClause `;`
+
+ 1. Let _module_ be the sole element of ModuleRequests of |FromClause|.
+ 1. Return ExportEntriesForModule of |ExportClause| with argument _module_.
+
+ ExportDeclaration : `export` ExportClause `;`
+
+ 1. Return ExportEntriesForModule of |ExportClause| with argument *null*.
+
+ ExportDeclaration : `export` VariableStatement
+
+ 1. Let _entries_ be a new empty List.
+ 1. Let _names_ be the BoundNames of |VariableStatement|.
+ 1. Repeat for each _name_ in _names_,
+ 1. Append to _entries_ the Record {[[ModuleRequest]]: *null*, [[ImportName]]: *null*, [[LocalName]]: _name_, [[ExportName]]: _name_ }.
+ 1. Return _entries_.
+
+ ExportDeclaration : `export` Declaration
+
+ 1. Let _entries_ be a new empty List.
+ 1. Let _names_ be the BoundNames of |Declaration|.
+ 1. Repeat for each _name_ in _names_,
+ 1. Append to _entries_ the Record {[[ModuleRequest]]: *null*, [[ImportName]]: *null*, [[LocalName]]: _name_, [[ExportName]]: _name_ }.
+ 1. Return _entries_.
+
+ ExportDeclaration : `export` `default` HoistableDeclaration
+
+ 1. Let _names_ be BoundNames of |HoistableDeclaration|.
+ 1. Let _localName_ be the sole element of _names_.
+ 1. Return a new List containing the Record {[[ModuleRequest]]: *null*, [[ImportName]]: *null*, [[LocalName]]: _localName_, [[ExportName]]: `"default"`}.
+
+ ExportDeclaration : `export` `default` ClassDeclaration
+
+ 1. Let _names_ be BoundNames of |ClassDeclaration|.
+ 1. Let _localName_ be the sole element of _names_.
+ 1. Return a new List containing the Record {[[ModuleRequest]]: *null*, [[ImportName]]: *null*, [[LocalName]]: _localName_, [[ExportName]]: `"default"`}.
+
+ ExportDeclaration : `export` `default` AssignmentExpression `;`
+
+ 1. Let _entry_ be the Record {[[ModuleRequest]]: *null*, [[ImportName]]: *null*, [[LocalName]]: `"*default*"`, [[ExportName]]: `"default"`}.
+ 1. Return a new List containing _entry_.
+
+
+
`"*default*"` is used within this specification as a synthetic name for anonymous default export values.
+
+
+
+
+
+
Static Semantics: ExportEntriesForModule
+
With parameter _module_.
+ ExportClause : `{` `}`
+
+ 1. Return a new empty List.
+
+ ExportsList : ExportsList `,` ExportSpecifier
+
+ 1. Let _specs_ be the ExportEntriesForModule of |ExportsList| with argument _module_.
+ 1. Append to _specs_ the elements of the ExportEntriesForModule of |ExportSpecifier| with argument _module_.
+ 1. Return _specs_.
+
+ ExportSpecifier : IdentifierName
+
+ 1. Let _sourceName_ be the StringValue of |IdentifierName|.
+ 1. If _module_ is *null*, then
+ 1. Let _localName_ be _sourceName_.
+ 1. Let _importName_ be *null*.
+ 1. Else,
+ 1. Let _localName_ be *null*.
+ 1. Let _importName_ be _sourceName_.
+ 1. Return a new List containing the Record {[[ModuleRequest]]: _module_, [[ImportName]]: _importName_, [[LocalName]]: _localName_, [[ExportName]]: _sourceName_ }.
+
+ ExportSpecifier : IdentifierName `as` IdentifierName
+
+ 1. Let _sourceName_ be the StringValue of the first |IdentifierName|.
+ 1. Let _exportName_ be the StringValue of the second |IdentifierName|.
+ 1. If _module_ is *null*, then
+ 1. Let _localName_ be _sourceName_.
+ 1. Let _importName_ be *null*.
+ 1. Else,
+ 1. Let _localName_ be *null*.
+ 1. Let _importName_ be _sourceName_.
+ 1. Return a new List containing the Record {[[ModuleRequest]]: _module_, [[ImportName]]: _importName_, [[LocalName]]: _localName_, [[ExportName]]: _exportName_ }.
+
+
+
+
+
+
It is not necessary to treat `export default` |AssignmentExpression| as a constant declaration because there is no syntax that permits assignment to the internal bound name used to reference a module's default object.
+
+
+
+
+
+
Static Semantics: LexicallyScopedDeclarations
+
+
+ ExportDeclaration :
+ `export` `*` FromClause `;`
+ `export` ExportClause FromClause `;`
+ `export` ExportClause `;`
+ `export` VariableStatement
+
+
+ 1. Return a new empty List.
+
+ ExportDeclaration : `export` Declaration
+
+ 1. Return a new List containing DeclarationPart of |Declaration|.
+
+ ExportDeclaration : `export` `default` HoistableDeclaration
+
+ 1. Return a new List containing DeclarationPart of |HoistableDeclaration|.
+
+ ExportDeclaration : `export` `default` ClassDeclaration
+
+ 1. Return a new List containing |ClassDeclaration|.
+
+ ExportDeclaration : `export` `default` AssignmentExpression `;`
+
+ 1. Return a new List containing this |ExportDeclaration|.
+
+
+
+
+
+
+ ExportClause : `{` `}`
+
+ 1. Return a new empty List.
+
+ ExportsList : ExportsList `,` ExportSpecifier
+
+ 1. Let _names_ be the ReferencedBindings of |ExportsList|.
+ 1. Append to _names_ the elements of the ReferencedBindings of |ExportSpecifier|.
+ 1. Return _names_.
+
+ ExportSpecifier : IdentifierName
+
+ 1. Return a List containing the |IdentifierName|.
+
+ ExportSpecifier : IdentifierName `as` IdentifierName
+
+ 1. Return a List containing the first |IdentifierName|.
+
+
+
+
+
+
Runtime Semantics: Evaluation
+
+ ExportDeclaration :
+ `export` `*` FromClause `;`
+ `export` ExportClause FromClause `;`
+ `export` ExportClause `;`
+
+
+ 1. Return NormalCompletion(~empty~).
+
+ ExportDeclaration : `export` VariableStatement
+
+ 1. Return the result of evaluating |VariableStatement|.
+
+ ExportDeclaration : `export` Declaration
+
+ 1. Return the result of evaluating |Declaration|.
+
+ ExportDeclaration : `export` `default` HoistableDeclaration
+
+ 1. Return the result of evaluating |HoistableDeclaration|.
+
+ ExportDeclaration : `export` `default` ClassDeclaration
+
+ 1. Let _value_ be the result of BindingClassDeclarationEvaluation of |ClassDeclaration|.
+ 1. ReturnIfAbrupt(_value_).
+ 1. Let _className_ be the sole element of BoundNames of |ClassDeclaration|.
+ 1. If _className_ is `"*default*"`, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_value_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_value_, `"default"`).
+ 1. Let _env_ be the running execution context's LexicalEnvironment.
+ 1. Let _status_ be ? InitializeBoundName(`"*default*"`, _value_, _env_).
+ 1. Return NormalCompletion(~empty~).
+
+ ExportDeclaration : `export` `default` AssignmentExpression `;`
+
+ 1. Let _rhs_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _value_ be ? GetValue(_rhs_).
+ 1. If IsAnonymousFunctionDefinition(|AssignmentExpression|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_value_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_value_, `"default"`).
+ 1. Let _env_ be the running execution context's LexicalEnvironment.
+ 1. Let _status_ be InitializeBoundName(`"*default*"`, _value_, _env_).
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
+
+
+
+
+
Error Handling and Language Extensions
+
An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. An early error is an error that can be detected and reported prior to the evaluation of any construct in the |Script| containing the error. The presence of an early error prevents the evaluation of the construct. An implementation must report early errors in a |Script| as part of parsing that |Script| in ParseScript. Early errors in a |Module| are reported at the point when the |Module| would be evaluated and the |Module| is never initialized. Early errors in eval code are reported at the time `eval` is called and prevent evaluation of the eval code. All errors that are not early errors are runtime errors.
+
An implementation must report as an early error any occurrence of a condition that is listed in a “Static Semantics: Early Errors” subclause of this specification.
+
An implementation shall not treat other kinds of errors as early errors even if the compiler can prove that a construct cannot execute without error under any circumstances. An implementation may issue an early warning in such a case, but it should not report the error until the relevant construct is actually executed.
+
An implementation shall report all errors as specified, except for the following:
+
+
+ Except as restricted in , an implementation may extend |Script| syntax, |Module| syntax, and regular expression pattern or flag syntax. To permit this, all operations (such as calling `eval`, using a regular expression literal, or using the `Function` or `RegExp` constructor) that are allowed to throw *SyntaxError* are permitted to exhibit implementation-defined behaviour instead of throwing *SyntaxError* when they encounter an implementation-defined extension to the script syntax or regular expression pattern or flag syntax.
+
+
+ Except as restricted in , an implementation may provide additional types, values, objects, properties, and functions beyond those described in this specification. This may cause constructs (such as looking up a variable in the global scope) to have implementation-defined behaviour instead of throwing an error (such as *ReferenceError*).
+
+
+
An implementation may define behaviour other than throwing *RangeError* for `toFixed`, `toExponential`, and `toPrecision` when the _fractionDigits_ or _precision_ argument is outside the specified range.
+
+
+
+
Forbidden Extensions
+
An implementation must not extend this specification in the following ways:
+
+
+ Other than as defined in this specification, ECMAScript Function objects defined using syntactic constructors in strict mode code must not be created with own properties named `"caller"` or `"arguments"` other than those that are created by applying the AddRestrictedFunctionProperties abstract operation () to the function. Such own properties also must not be created for function objects defined using an |ArrowFunction|, |MethodDefinition|, |GeneratorDeclaration|, |GeneratorExpression|, |ClassDeclaration|, or |ClassExpression| regardless of whether the definition is contained in strict mode code. Built-in functions, strict mode functions created using the `Function` constructor, generator functions created using the `Generator` constructor, and functions created using the `bind` method also must not be created with such own properties.
+
+
+ If an implementation extends non-strict or built-in function objects with an own property named `"caller"` the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+
+
+ The behaviour of the following methods must not be extended except as specified in ECMA-402: `Object.prototype.toLocaleString`, `Array.prototype.toLocaleString`, `Number.prototype.toLocaleString`, `Date.prototype.toLocaleDateString`, `Date.prototype.toLocaleString`, `Date.prototype.toLocaleTimeString`, `String.prototype.localeCompare`, `%TypedArray%.prototype.toLocaleString`.
+
+
+ The RegExp pattern grammars in and must not be extended to recognize any of the source characters A-Z or a-z as |IdentityEscape[U]| when the U grammar parameter is present.
+
+
+ The Syntactic Grammar must not be extended in any manner that allows the token `:` to immediate follow source text that matches the |BindingIdentifier| nonterminal symbol.
+
+
+ When processing strict mode code, the syntax of |NumericLiteral| must not be extended to include |LegacyOctalIntegerLiteral| as defined in .
+
+
+ |TemplateCharacter| () must not be extended to include |LegacyOctalEscapeSequence| as defined in .
+
+
+ When processing strict mode code, the extensions defined in , , and must not be supported.
+
+
+ When parsing for the |Module| goal symbol, the lexical grammar extensions defined in must not be supported.
+
+
+
+
+
+
+
+
ECMAScript Standard Built-in Objects
+
There are certain built-in objects available whenever an ECMAScript |Script| or |Module| begins execution. One, the global object, is part of the lexical environment of the executing program. Others are accessible as initial properties of the global object or indirectly as properties of accessible built-in objects.
+
Unless specified otherwise, a built-in object that is callable as a function is a built-in Function object with the characteristics described in . Unless specified otherwise, the [[Extensible]] internal slot of a built-in object initially has the value *true*. Every built-in Function object has a [[Realm]] internal slot whose value is the code Realm for which the object was initially created.
+
Many built-in objects are functions: they can be invoked with arguments. Some of them furthermore are constructors: they are functions intended for use with the `new` operator. For each built-in function, this specification describes the arguments required by that function and the properties of that function object. For each built-in constructor, this specification furthermore describes properties of the prototype object of that constructor and properties of specific object instances returned by a `new` expression that invokes that constructor.
+
Unless otherwise specified in the description of a particular function, if a built-in function or constructor is given fewer arguments than the function is specified to require, the function or constructor shall behave exactly as if it had been given sufficient additional arguments, each such argument being the *undefined* value. Such missing arguments are considered to be “not present” and may be identified in that manner by specification algorithms. In the description of a particular function, the terms “`this` value” and “NewTarget” have the meanings given in .
+
Unless otherwise specified in the description of a particular function, if a built-in function or constructor described is given more arguments than the function is specified to allow, the extra arguments are evaluated by the call and then ignored by the function. However, an implementation may define implementation specific behaviour relating to such arguments as long as the behaviour is not the throwing of a *TypeError* exception that is predicated simply on the presence of an extra argument.
+
+
Implementations that add additional capabilities to the set of built-in functions are encouraged to do so by adding new functions rather than adding new parameters to existing functions.
+
+
Unless otherwise specified every built-in function and every built-in constructor has the Function prototype object, which is the initial value of the expression `Function.prototype` (), as the value of its [[Prototype]] internal slot.
+
Unless otherwise specified every built-in prototype object has the Object prototype object, which is the initial value of the expression `Object.prototype` (), as the value of its [[Prototype]] internal slot, except the Object prototype object itself.
+
Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function.
+
Unless otherwise specified, each built-in function defined in this specification is created as if by calling the CreateBuiltinFunction abstract operation ().
+
Every built-in Function object, including constructors, has a `length` property whose value is an integer. Unless otherwise specified, this value is equal to the largest number of named arguments shown in the subclause headings for the function description, including optional parameters. However, rest parameters shown using the form “...name” are not included in the default argument count.
+
+
For example, the function object that is the initial value of the `slice` property of the String prototype object is described under the subclause heading “String.prototype.slice (start, end)” which shows the two named arguments start and end; therefore the value of the `length` property of that Function object is `2`.
+
+
Unless otherwise specified, the `length` property of a built-in Function object has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
Every built-in Function object, including constructors, that is not identified as an anonymous function has a `name` property whose value is a String. Unless otherwise specified, this value is the name that is given to the function in this specification. For functions that are specified as properties of objects, the name value is the property name string used to access the function. Functions that are specified as get or set accessor functions of built-in properties have `"get "` or `"set "` prepended to the property name string. The value of the `name` property is explicitly specified for each built-in functions whose property key is a Symbol value.
+
Unless otherwise specified, the `name` property of a built-in Function object, if it exists, has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
Every other data property described in clauses 18 through 26 and in Annex has the attributes { [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true* } unless otherwise specified.
+
Every accessor property described in clauses 18 through 26 and in Annex has the attributes {[[Enumerable]]: *false*, [[Configurable]]: *true* } unless otherwise specified. If only a get accessor function is described, the set accessor function is the default value, *undefined*. If only a set accessor is described the get accessor is the default value, *undefined*.
+
+
+
+
+
The Global Object
+
The unique global object is created before control enters any execution context.
+
The global object does not have a [[Construct]] internal method; it is not possible to use the global object as a constructor with the `new` operator.
+
The global object does not have a [[Call]] internal method; it is not possible to invoke the global object as a function.
+
The value of the [[Prototype]] internal slot of the global object is implementation-dependent.
+
In addition to the properties defined in this specification the global object may have additional host defined properties. This may include a property whose value is the global object itself; for example, in the HTML document object model the `window` property of the global object is the global object itself.
+
+
+
+
Value Properties of the Global Object
+
+
+
+
Infinity
+
The value of `Infinity` is *+∞* (see ). This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
NaN
+
The value of `NaN` is *NaN* (see ). This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
undefined
+
The value of `undefined` is *undefined* (see ). This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Function Properties of the Global Object
+
+
+
+
eval (_x_)
+
The `eval` function is the %eval% intrinsic object. When the `eval` function is called with one argument _x_, the following steps are taken:
+
+ 1. Let _evalRealm_ be the value of the active function object's [[Realm]] internal slot.
+ 1. Let _strictCaller_ be *false*.
+ 1. Let _directEval_ be *false*.
+ 1. Return PerformEval(_x_, _evalRealm_, _strictCaller_, _directEval_).
+
+
+
+
+
The abstract operation PerformEval with arguments _x_, _evalRealm_, _strictCaller_, and _direct_ performs the following steps:
+
+ 1. Assert: If _direct_ is *false* then _strictCaller_ is also *false*.
+ 1. If Type(_x_) is not String, return _x_.
+ 1. Let _script_ be the ECMAScript code that is the result of parsing _x_, interpreted as UTF-16 encoded Unicode text as described in , for the goal symbol |Script|. If the parse fails, throw a *SyntaxError* exception. If any early errors are detected, throw a *SyntaxError* or a *ReferenceError* exception, depending on the type of the error (but see also clause ). Parsing and early error detection may be interweaved in an implementation dependent manner.
+ 1. If _script_ Contains |ScriptBody| is *false*, return *undefined*.
+ 1. Let _body_ be the |ScriptBody| of _script_.
+ 1. If _strictCaller_ is *true*, let _strictEval_ be *true*.
+ 1. Else, let _strictEval_ be IsStrict of _script_.
+ 1. Let _ctx_ be the running execution context. If _direct_ is *true* _ctx_ will be the execution context that performed the direct `eval`. If _direct_ is *false* _ctx_ will be the execution context for the invocation of the eval function.
+ 1. If _direct_ is *true*, then
+ 1. Let _lexEnv_ be NewDeclarativeEnvironment(_ctx_'s LexicalEnvironment).
+ 1. Let _varEnv_ be _ctx_'s VariableEnvironment.
+ 1. Else,
+ 1. Let _lexEnv_ be NewDeclarativeEnvironment(_evalRealm_.[[globalEnv]]).
+ 1. Let _varEnv_ be _evalRealm_.[[globalEnv]].
+ 1. If _strictEval_ is *true*, let _varEnv_ be _lexEnv_.
+ 1. If _ctx_ is not already suspended, Suspend _ctx_.
+ 1. Let _evalCxt_ be a new ECMAScript code execution context.
+ 1. Set the _evalCxt_'s Function to *null*.
+ 1. Set the _evalCxt_'s Realm to _evalRealm_.
+ 1. Set the _evalCxt_'s ScriptOrModule to _ctx_'s ScriptOrModule.
+ 1. Set the _evalCxt_'s VariableEnvironment to _varEnv_.
+ 1. Set the _evalCxt_'s LexicalEnvironment to _lexEnv_.
+ 1. Push _evalCxt_ on to the execution context stack; _evalCxt_ is now the running execution context.
+ 1. Let _result_ be EvalDeclarationInstantiation(_body_, _varEnv_, _lexEnv_, _strictEval_).
+ 1. If _result_.[[type]] is ~normal~, then
+ 1. Let _result_ be the result of evaluating _body_.
+ 1. If _result_.[[type]] is ~normal~ and _result_.[[value]] is ~empty~, then
+ 1. Let _result_ be NormalCompletion(*undefined*).
+ 1. Suspend _evalCxt_ and remove it from the execution context stack.
+ 1. Resume the context that is now on the top of the execution context stack as the running execution context.
+ 1. Return Completion(_result_).
+
+
+
The eval code cannot instantiate variable or function bindings in the variable environment of the calling context that invoked the eval if the calling context is evaluating formal parameter initializers or if either the code of the calling context or the eval code is strict code. Instead such bindings are instantiated in a new VariableEnvironment that is only accessible to the eval code. Bindings introduced by `let`, `const`, or `class` declarations are always instantiated in a new LexicalEnvironment.
When the abstract operation EvalDeclarationInstantiation is called with arguments _body_, _varEnv_, _lexEnv_, and _strict_ the following steps are taken:
+
+ 1. Let _varNames_ be the VarDeclaredNames of _body_.
+ 1. Let _varDeclarations_ be the VarScopedDeclarations of _body_.
+ 1. Let _lexEnvRec_ be _lexEnv_'s EnvironmentRecord.
+ 1. Let _varEnvRec_ be _varEnv_'s EnvironmentRecord.
+ 1. If _strict_ is *false*, then
+ 1. If _varEnvRec_ is a global Environment Record, then
+ 1. For each _name_ in _varNames_, do
+ 1. If _varEnvRec_.HasLexicalDeclaration(_name_) is *true*, throw a *SyntaxError* exception.
+ 1. NOTE: `eval` will not create a global var declaration that would be shadowed by a global lexical declaration.
+ 1. Let _thisLex_ be _lexEnv_.
+ 1. Assert: the following loop will terminate.
+ 1. Repeat while _thisLex_ is not the same as _varEnv_,
+ 1. Let _thisEnvRec_ be _thisLex_'s EnvironmentRecord.
+ 1. If _thisEnvRec_ is not an object Environment Record, then
+ 1. NOTE: The environment of with statements cannot contain any lexical declaration so it doesn't need to be checked for var/let hoisting conflicts.
+ 1. For each _name_ in _varNames_, do
+ 1. If _thisEnvRec_.HasBinding(_name_) is *true*, then
+ 1. Throw a *SyntaxError* exception.
+ 1. NOTE: A direct `eval` will not hoist var declaration over a like-named lexical declaration.
+ 1. Let _thisLex_ be _thisLex_'s outer environment reference.
+ 1. Let _functionsToInitialize_ be an empty List.
+ 1. Let _declaredFunctionNames_ be an empty List.
+ 1. For each _d_ in _varDeclarations_, in reverse list order do
+ 1. If _d_ is neither a |VariableDeclaration| or a |ForBinding|, then
+ 1. Assert: _d_ is either a |FunctionDeclaration| or a |GeneratorDeclaration|.
+ 1. NOTE If there are multiple |FunctionDeclaration|s for the same name, the last declaration is used.
+ 1. Let _fn_ be the sole element of the BoundNames of _d_.
+ 1. If _fn_ is not an element of _declaredFunctionNames_, then
+ 1. If _varEnvRec_ is a global Environment Record, then
+ 1. Let _fnDefinable_ be ? _varEnvRec_.CanDeclareGlobalFunction(_fn_).
+ 1. If _fnDefinable_ is *false*, throw a *TypeError* exception.
+ 1. Append _fn_ to _declaredFunctionNames_.
+ 1. Insert _d_ as the first element of _functionsToInitialize_.
+ 1. NOTE: Annex adds additional steps at this point.
+ 1. Let _declaredVarNames_ be an empty List.
+ 1. For each _d_ in _varDeclarations_, do
+ 1. If _d_ is a |VariableDeclaration| or a |ForBinding|, then
+ 1. For each String _vn_ in the BoundNames of _d_, do
+ 1. If _vn_ is not an element of _declaredFunctionNames_, then
+ 1. If _varEnvRec_ is a global Environment Record, then
+ 1. Let _vnDefinable_ be ? _varEnvRec_.CanDeclareGlobalVar(_vn_).
+ 1. If _vnDefinable_ is *false*, throw a *TypeError* exception.
+ 1. If _vn_ is not an element of _declaredVarNames_, then
+ 1. Append _vn_ to _declaredVarNames_.
+ 1. NOTE: No abnormal terminations occur after this algorithm step unless _varEnvRec_ is a global Environment Record and the global object is a Proxy exotic object.
+ 1. Let _lexDeclarations_ be the LexicallyScopedDeclarations of _body_.
+ 1. For each element _d_ in _lexDeclarations_ do
+ 1. NOTE Lexically declared names are only instantiated here but not initialized.
+ 1. For each element _dn_ of the BoundNames of _d_ do
+ 1. If IsConstantDeclaration of _d_ is *true*, then
+ 1. Let _status_ be _lexEnvRec_.CreateImmutableBinding(_dn_, *true*).
+ 1. Else,
+ 1. Let _status_ be _lexEnvRec_.CreateMutableBinding(_dn_, *false*).
+ 1. ReturnIfAbrupt(_status_).
+ 1. For each production _f_ in _functionsToInitialize_, do
+ 1. Let _fn_ be the sole element of the BoundNames of _f_.
+ 1. Let _fo_ be the result of performing InstantiateFunctionObject for _f_ with argument _lexEnv_.
+ 1. If _varEnvRec_ is a global Environment Record, then
+ 1. Let _status_ be ? _varEnvRec_.CreateGlobalFunctionBinding(_fn_, _fo_, *true*).
+ 1. Else,
+ 1. Let _bindingExists_ be _varEnvRec_.HasBinding(_fn_).
+ 1. If _bindingExists_ is *false*, then
+ 1. Let _status_ be _varEnvRec_.CreateMutableBinding(_fn_, *true*).
+ 1. Assert: _status_ is not an abrupt completion because of validation preceding step 12.
+ 1. Let _status_ be _varEnvRec_.InitializeBinding(_fn_, _fo_).
+ 1. Else,
+ 1. Let _status_ be _varEnvRec_.SetMutableBinding(_fn_, _fo_, *false*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. For each String _vn_ in _declaredVarNames_, in list order do
+ 1. If _varEnvRec_ is a global Environment Record, then
+ 1. Let _status_ be ? _varEnvRec_.CreateGlobalVarBinding(_vn_, *true*).
+ 1. Else,
+ 1. Let _bindingExists_ be _varEnvRec_.HasBinding(_vn_).
+ 1. If _bindingExists_ is *false*, then
+ 1. Let _status_ be _varEnvRec_.CreateMutableBinding(_vn_, *true*).
+ 1. Assert: _status_ is not an abrupt completion because of validation preceding step 12.
+ 1. Let _status_ be _varEnvRec_.InitializeBinding(_vn_, *undefined*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return NormalCompletion(~empty~).
+
+
+
An alternative version of this algorithm is described in .
+
+
+
+
+
+
+
isFinite (_number_)
+
The `isFinite` function is the %isFinite% intrinsic object. When the `isFinite` function is called with one argument _number_, the following steps are taken:
+
+ 1. Let _num_ be ? ToNumber(_number_).
+ 1. If _num_ is *NaN*, *+∞*, or *-∞*, return *false*.
+ 1. Otherwise, return *true*.
+
+
+
+
+
+
isNaN (_number_)
+
The `isNaN` function is the %isNaN% intrinsic object. When the `isNaN` function is called with one argument _number_, the following steps are taken:
+
+ 1. Let _num_ be ? ToNumber(_number_).
+ 1. If _num_ is *NaN*, return *true*.
+ 1. Otherwise, return *false*.
+
+
+
A reliable way for ECMAScript code to test if a value `X` is a *NaN* is an expression of the form `X !== X`. The result will be *true* if and only if `X` is a *NaN*.
+
+
+
+
+
+
parseFloat (_string_)
+
The `parseFloat` function produces a Number value dictated by interpretation of the contents of the _string_ argument as a decimal literal.
+
The `parseFloat` function is the %parseFloat% intrinsic object. When the `parseFloat` function is called with one argument _string_, the following steps are taken:
+
+ 1. Let _inputString_ be ? ToString(_string_).
+ 1. Let _trimmedString_ be a substring of _inputString_ consisting of the leftmost code unit that is not a |StrWhiteSpaceChar| and all code units to the right of that code unit. (In other words, remove leading white space.) If _inputString_ does not contain any such code units, let _trimmedString_ be the empty string.
+ 1. If neither _trimmedString_ nor any prefix of _trimmedString_ satisfies the syntax of a |StrDecimalLiteral| (see ), return *NaN*.
+ 1. Let _numberString_ be the longest prefix of _trimmedString_, which might be _trimmedString_ itself, that satisfies the syntax of a |StrDecimalLiteral|.
+ 1. Let _mathFloat_ be MV of _numberString_.
+ 1. If _mathFloat_=0, then
+ 1. If the first code unit of _trimmedString_ is `"-"`, return -0.
+ 1. Return +0.
+ 1. Return the Number value for _mathFloat_.
+
+
+
`parseFloat` may interpret only a leading portion of _string_ as a Number value; it ignores any code units that cannot be interpreted as part of the notation of an decimal literal, and no indication is given that any such code units were ignored.
+
+
+
+
+
+
parseInt (_string_ , _radix_)
+
The `parseInt` function produces an integer value dictated by interpretation of the contents of the _string_ argument according to the specified _radix_. Leading white space in _string_ is ignored. If _radix_ is *undefined* or 0, it is assumed to be 10 except when the number begins with the code unit pairs `0x` or `0X`, in which case a radix of 16 is assumed. If _radix_ is 16, the number may also optionally begin with the code unit pairs `0x` or `0X`.
+
The `parseInt` function is the %parseInt% intrinsic object. When the `parseInt` function is called, the following steps are taken:
+
+ 1. Let _inputString_ be ? ToString(_string_).
+ 1. Let _S_ be a newly created substring of _inputString_ consisting of the first code unit that is not a |StrWhiteSpaceChar| and all code units following that code unit. (In other words, remove leading white space.) If _inputString_ does not contain any such code unit, let _S_ be the empty string.
+ 1. Let _sign_ be 1.
+ 1. If _S_ is not empty and the first code unit of _S_ is 0x002D (HYPHEN-MINUS), let _sign_ be -1.
+ 1. If _S_ is not empty and the first code unit of _S_ is 0x002B (PLUS SIGN) or 0x002D (HYPHEN-MINUS), remove the first code unit from _S_.
+ 1. Let _R_ be ? ToInt32(_radix_).
+ 1. Let _stripPrefix_ be *true*.
+ 1. If _R_ ≠ 0, then
+ 1. If _R_ < 2 or _R_ > 36, return *NaN*.
+ 1. If _R_ ≠ 16, let _stripPrefix_ be *false*.
+ 1. Else _R_ = 0,
+ 1. Let _R_ be 10.
+ 1. If _stripPrefix_ is *true*, then
+ 1. If the length of _S_ is at least 2 and the first two code units of _S_ are either `"0x"` or `"0X"`, remove the first two code units from _S_ and let _R_ be 16.
+ 1. If _S_ contains a code unit that is not a radix-_R_ digit, let _Z_ be the substring of _S_ consisting of all code units before the first such code unit; otherwise, let _Z_ be _S_.
+ 1. If _Z_ is empty, return *NaN*.
+ 1. Let _mathInt_ be the mathematical integer value that is represented by _Z_ in radix-_R_ notation, using the letters A-Z and a-z for digits with values 10 through 35. (However, if _R_ is 10 and _Z_ contains more than 20 significant digits, every significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation; and if _R_ is not 2, 4, 8, 10, 16, or 32, then _mathInt_ may be an implementation-dependent approximation to the mathematical integer value that is represented by _Z_ in radix-_R_ notation.)
+ 1. If _mathInt_ = 0, then
+ 1. If _sign_ = -1, return -0.
+ 1. Return +0.
+ 1. Let _number_ be the Number value for _mathInt_.
+ 1. Return _sign_ × _number_.
+
+
+
`parseInt` may interpret only a leading portion of _string_ as an integer value; it ignores any code units that cannot be interpreted as part of the notation of an integer, and no indication is given that any such code units were ignored.
+
+
+
+
+
+
URI Handling Functions
+
Uniform Resource Identifiers, or URIs, are Strings that identify resources (e.g. web pages or files) and transport protocols by which to access them (e.g. HTTP or FTP) on the Internet. The ECMAScript language itself does not provide any support for using URIs except for functions that encode and decode URIs as described in , , and
+
+
Many implementations of ECMAScript provide additional functions and methods that manipulate web pages; these functions are beyond the scope of this standard.
+
+
+
+
+
URI Syntax and Semantics
+
A URI is composed of a sequence of components separated by component separators. The general form is:
where the italicized names represent components and “`:`”, “`/`”, “`;`” and “`?`” are reserved for use as separators. The `encodeURI` and `decodeURI` functions are intended to work with complete URIs; they assume that any reserved code units in the URI are intended to have special meaning and so are not encoded. The `encodeURIComponent` and `decodeURIComponent` functions are intended to work with the individual component parts of a URI; they assume that any reserved code units represent text and so must be encoded so that they are not interpreted as reserved code units when the component is part of a complete URI.
+
The following lexical grammar specifies the form of encoded URIs.
The above syntax is based upon RFC 2396 and does not reflect changes introduced by the more recent RFC 3986.
+
+
Runtime Semantics
+
When a code unit to be included in a URI is not listed above or is not intended to have the special meaning sometimes given to the reserved code units, that code unit must be encoded. The code unit is transformed into its UTF-8 encoding, with surrogate pairs first converted from UTF-16 to the corresponding code point value. (Note that for code units in the range [0,127] this results in a single octet with the same value.) The resulting sequence of octets is then transformed into a String with each octet represented by an escape sequence of the form `"%xx"`.
The encoding and escaping process is described by the abstract operation Encode taking two String arguments _string_ and _unescapedSet_.
+
+ 1. Let _strLen_ be the number of code units in _string_.
+ 1. Let _R_ be the empty String.
+ 1. Let _k_ be 0.
+ 1. Repeat
+ 1. If _k_ equals _strLen_, return _R_.
+ 1. Let _C_ be the code unit at index _k_ within _string_.
+ 1. If _C_ is in _unescapedSet_, then
+ 1. Let _S_ be a String containing only the code unit _C_.
+ 1. Let _R_ be a new String value computed by concatenating the previous value of _R_ and _S_.
+ 1. Else _C_ is not in _unescapedSet_,
+ 1. If the code unit value of _C_ is not less than 0xDC00 and not greater than 0xDFFF, throw a *URIError* exception.
+ 1. If the code unit value of _C_ is less than 0xD800 or greater than 0xDBFF, then
+ 1. Let _V_ be the code unit value of _C_.
+ 1. Else,
+ 1. Increase _k_ by 1.
+ 1. If _k_ equals _strLen_, throw a *URIError* exception.
+ 1. Let _kChar_ be the code unit value of the code unit at index _k_ within _string_.
+ 1. If _kChar_ is less than 0xDC00 or greater than 0xDFFF, throw a *URIError* exception.
+ 1. Let _V_ be UTF16Decode(_C_, _kChar_).
+ 1. Let _Octets_ be the array of octets resulting by applying the UTF-8 transformation to _V_, and let _L_ be the array size.
+ 1. Let _j_ be 0.
+ 1. Repeat, while _j_ < _L_
+ 1. Let _jOctet_ be the value at index _j_ within _Octets_.
+ 1. Let _S_ be a String containing three code units "%XY" where _XY_ are two uppercase hexadecimal digits encoding the value of _jOctet_.
+ 1. Let _R_ be a new String value computed by concatenating the previous value of _R_ and _S_.
+ 1. Increase _j_ by 1.
+ 1. Increase _k_ by 1.
+
+
+
+
+
+
The unescaping and decoding process is described by the abstract operation Decode taking two String arguments _string_ and _reservedSet_.
+
+ 1. Let _strLen_ be the number of code units in _string_.
+ 1. Let _R_ be the empty String.
+ 1. Let _k_ be 0.
+ 1. Repeat
+ 1. If _k_ equals _strLen_, return _R_.
+ 1. Let _C_ be the code unit at index _k_ within _string_.
+ 1. If _C_ is not `"%"`, then
+ 1. Let _S_ be the String containing only the code unit _C_.
+ 1. Else _C_ is `"%"`,
+ 1. Let _start_ be _k_.
+ 1. If _k_ + 2 is greater than or equal to _strLen_, throw a *URIError* exception.
+ 1. If the code units at index (_k_+1) and (_k_ + 2) within _string_ do not represent hexadecimal digits, throw a *URIError* exception.
+ 1. Let _B_ be the 8-bit value represented by the two hexadecimal digits at index (_k_ + 1) and (_k_ + 2).
+ 1. Increment _k_ by 2.
+ 1. If the most significant bit in _B_ is 0, then
+ 1. Let _C_ be the code unit with code unit value _B_.
+ 1. If _C_ is not in _reservedSet_, then
+ 1. Let _S_ be the String containing only the code unit _C_.
+ 1. Else _C_ is in _reservedSet_,
+ 1. Let _S_ be the substring of _string_ from index _start_ to index _k_ inclusive.
+ 1. Else the most significant bit in _B_ is 1,
+ 1. Let _n_ be the smallest nonnegative integer such that (_B_ << _n_) & 0x80 is equal to 0.
+ 1. If _n_ equals 1 or _n_ is greater than 4, throw a *URIError* exception.
+ 1. Let _Octets_ be an array of 8-bit integers of size _n_.
+ 1. Put _B_ into _Octets_ at index 0.
+ 1. If _k_ + (3 × (_n_ - 1)) is greater than or equal to _strLen_, throw a *URIError* exception.
+ 1. Let _j_ be 1.
+ 1. Repeat, while _j_ < _n_
+ 1. Increment _k_ by 1.
+ 1. If the code unit at index _k_ within _string_ is not `"%"`, throw a *URIError* exception.
+ 1. If the code units at index (_k_ +1) and (_k_ + 2) within _string_ do not represent hexadecimal digits, throw a *URIError* exception.
+ 1. Let _B_ be the 8-bit value represented by the two hexadecimal digits at index (_k_ + 1) and (_k_ + 2).
+ 1. If the two most significant bits in _B_ are not 10, throw a *URIError* exception.
+ 1. Increment _k_ by 2.
+ 1. Put _B_ into _Octets_ at index _j_.
+ 1. Increment _j_ by 1.
+ 1. Let _V_ be the value obtained by applying the UTF-8 transformation to _Octets_, that is, from an array of octets into a 21-bit value. If _Octets_ does not contain a valid UTF-8 encoding of a Unicode code point throw a *URIError* exception.
+ 1. If _V_ < 0x10000, then
+ 1. Let _C_ be the code unit _V_.
+ 1. If _C_ is not in _reservedSet_, then
+ 1. Let _S_ be the String containing only the code unit _C_.
+ 1. Else _C_ is in _reservedSet_,
+ 1. Let _S_ be the substring of _string_ from index _start_ to index _k_ inclusive.
+ 1. Else _V_ ≥ 0x10000,
+ 1. Let _L_ be (((_V_ - 0x10000) & 0x3FF) + 0xDC00).
+ 1. Let _H_ be ((((_V_ - 0x10000) >> 10) & 0x3FF) + 0xD800).
+ 1. Let _S_ be the String containing the two code units _H_ and _L_.
+ 1. Let _R_ be a new String value computed by concatenating the previous value of _R_ and _S_.
+ 1. Increase _k_ by 1.
+
+
+
This syntax of Uniform Resource Identifiers is based upon RFC 2396 and does not reflect the more recent RFC 3986 which replaces RFC 2396. A formal description and implementation of UTF-8 is given in RFC 3629.
+
In UTF-8, characters are encoded using sequences of 1 to 6 octets. The only octet of a sequence of one has the higher-order bit set to 0, the remaining 7 bits being used to encode the character value. In a sequence of n octets, n>1, the initial octet has the n higher-order bits set to 1, followed by a bit set to 0. The remaining bits of that octet contain bits from the value of the character to be encoded. The following octets all have the higher-order bit set to 1 and the following bit set to 0, leaving 6 bits in each to contain bits from the character to be encoded. The possible UTF-8 encodings of ECMAScript characters are specified in .
+
+
+
+
+
+ Code Unit Value
+
+
+ Representation
+
+
+ 1st Octet
+
+
+ 2nd Octet
+
+
+ 3rd Octet
+
+
+ 4th Octet
+
+
+
+
+ `0x0000 - 0x007F`
+
+
+ 00000000 0zzzzzzz
+
+
+ 0zzzzzzz
+
+
+
+
+
+
+
+
+
+
+ `0x0080 - 0x07FF`
+
+
+ 00000yyy yyzzzzzz
+
+
+ 110yyyyy
+
+
+ 10zzzzzz
+
+
+
+
+
+
+
+
+ `0x0800 - 0xD7FF`
+
+
+ xxxxyyyy yyzzzzzz
+
+
+ 1110xxxx
+
+
+ 10yyyyyy
+
+
+ 10zzzzzz
+
+
+
+
+
+
+ `0xD800 - 0xDBFF`
+
+ followed by
+
+ `0xDC00 - 0xDFFF`
+
+
+ 110110vv vvwwwwxx
+
+ followed by
+
+ 110111yy yyzzzzzz
+
+
+ 11110uuu
+
+
+ 10uuwwww
+
+
+ 10xxyyyy
+
+
+ 10zzzzzz
+
+
+
+
+ `0xD800 - 0xDBFF`
+
+ not followed by
+
+ `0xDC00 - 0xDFFF`
+
+
+ causes `URIError`
+
+
+
+
+
+
+
+
+
+
+
+
+ `0xDC00 - 0xDFFF`
+
+
+ causes `URIError`
+
+
+
+
+
+
+
+
+
+
+
+
+ `0xE000 - 0xFFFF`
+
+
+ xxxxyyyy yyzzzzzz
+
+
+ 1110xxxx
+
+
+ 10yyyyyy
+
+
+ 10zzzzzz
+
+
+
+
+
+
+
+
Where
+
+ _uuuuu_ = _vvvv_ + 1
+
+ to account for the addition of 0x10000 as in Surrogates, section 3.7, of the Unicode Standard.
+
The range of code unit values 0xD800-0xDFFF is used to encode surrogate pairs; the above transformation combines a UTF-16 surrogate pair into a UTF-32 representation and encodes the resulting 21-bit value in UTF-8. Decoding reconstructs the surrogate pair.
+
RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. For example, the invalid sequence C0 80 must not decode into the code unit 0x0000. Implementations of the Decode algorithm are required to throw a *URIError* when encountering such invalid sequences.
+
+
+
+
+
+
+
decodeURI (_encodedURI_)
+
The `decodeURI` function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the `encodeURI` function is replaced with the UTF-16 encoding of the code points that it represents. Escape sequences that could not have been introduced by `encodeURI` are not replaced.
+
The `decodeURI` function is the %decodeURI% intrinsic object. When the `decodeURI` function is called with one argument _encodedURI_, the following steps are taken:
+
+ 1. Let _uriString_ be ? ToString(_encodedURI_).
+ 1. Let _reservedURISet_ be a String containing one instance of each code unit valid in |uriReserved| plus `"#"`.
+ 1. Return Decode(_uriString_, _reservedURISet_).
+
+
+
The code point `"#"` is not decoded from escape sequences even though it is not a reserved URI code point.
+
+
+
+
+
+
decodeURIComponent (_encodedURIComponent_)
+
The `decodeURIComponent` function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the `encodeURIComponent` function is replaced with the UTF-16 encoding of the code points that it represents.
+
The `decodeURIComponent` function is the %decodeURIComponent% intrinsic object. When the `decodeURIComponent` function is called with one argument _encodedURIComponent_, the following steps are taken:
+
+ 1. Let _componentString_ be ? ToString(_encodedURIComponent_).
+ 1. Let _reservedURIComponentSet_ be the empty String.
+ 1. Return Decode(_componentString_, _reservedURIComponentSet_).
+
+
+
+
+
+
encodeURI (_uri_)
+
The `encodeURI` function computes a new version of a UTF-16 encoded () URI in which each instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the code points.
+
The `encodeURI` function is the %encodeURI% intrinsic object. When the `encodeURI` function is called with one argument _uri_, the following steps are taken:
+
+ 1. Let _uriString_ be ? ToString(_uri_).
+ 1. Let _unescapedURISet_ be a String containing one instance of each code unit valid in |uriReserved| and |uriUnescaped| plus `"#"`.
+ 1. Return Encode(_uriString_, _unescapedURISet_).
+
+
+
The code unit `"#"` is not encoded to an escape sequence even though it is not a reserved or unescaped URI code point.
+
+
+
+
+
+
encodeURIComponent (_uriComponent_)
+
The `encodeURIComponent` function computes a new version of a UTF-16 encoded () URI in which each instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the code point.
+
The `encodeURIComponent` function is the %encodeURIComponent% intrinsic object. When the `encodeURIComponent` function is called with one argument _uriComponent_, the following steps are taken:
+
+ 1. Let _componentString_ be ? ToString(_uriComponent_).
+ 1. Let _unescapedURIComponentSet_ be a String containing one instance of each code unit valid in |uriUnescaped|.
+ 1. Return Encode(_componentString_, _unescapedURIComponentSet_).
+
+
+
+
+
+
+
+
Constructor Properties of the Global Object
+
+
+
+
Array ( . . . )
+
See .
+
+
+
+
+
ArrayBuffer ( . . . )
+
See .
+
+
+
+
+
Boolean ( . . . )
+
See .
+
+
+
+
+
DataView ( . . . )
+
See .
+
+
+
+
+
Date ( . . . )
+
See .
+
+
+
+
+
Error ( . . . )
+
See .
+
+
+
+
+
EvalError ( . . . )
+
See .
+
+
+
+
+
Float32Array ( . . . )
+
See .
+
+
+
+
+
Float64Array ( . . . )
+
See .
+
+
+
+
+
Function ( . . . )
+
See .
+
+
+
+
+
Int8Array ( . . . )
+
See .
+
+
+
+
+
Int16Array ( . . . )
+
See .
+
+
+
+
+
Int32Array ( . . . )
+
See .
+
+
+
+
+
Map ( . . . )
+
See .
+
+
+
+
+
Number ( . . . )
+
See .
+
+
+
+
+
Object ( . . . )
+
See .
+
+
+
+
+
Proxy ( . . . )
+
See .
+
+
+
+
+
Promise ( . . . )
+
See .
+
+
+
+
+
RangeError ( . . . )
+
See .
+
+
+
+
+
ReferenceError ( . . . )
+
See .
+
+
+
+
+
RegExp ( . . . )
+
See .
+
+
+
+
+
Set ( . . . )
+
See .
+
+
+
+
+
String ( . . . )
+
See .
+
+
+
+
+
Symbol ( . . . )
+
See .
+
+
+
+
+
SyntaxError ( . . . )
+
See .
+
+
+
+
+
TypeError ( . . . )
+
See .
+
+
+
+
+
Uint8Array ( . . . )
+
See .
+
+
+
+
+
Uint8ClampedArray ( . . . )
+
See .
+
+
+
+
+
Uint16Array ( . . . )
+
See .
+
+
+
+
+
Uint32Array ( . . . )
+
See .
+
+
+
+
+
URIError ( . . . )
+
See .
+
+
+
+
+
WeakMap ( . . . )
+
See .
+
+
+
+
+
WeakSet ( . . . )
+
See .
+
+
+
+
+
+
Other Properties of the Global Object
+
+
+
+
JSON
+
See .
+
+
+
+
+
Math
+
See .
+
+
+
+
+
Reflect
+
See .
+
+
+
+
+
+
+
Fundamental Objects
+
+
+
+
Object Objects
+
+
+
+
The Object Constructor
+
The Object constructor is the %Object% intrinsic object and the initial value of the `Object` property of the global object. When called as a constructor it creates a new ordinary object. When `Object` is called as a function rather than as a constructor, it performs a type conversion.
+
The `Object` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition.
+
+
+
+
Object ( [ _value_ ] )
+
When `Object` function is called with optional argument _value_, the following steps are taken:
+
+ 1. If NewTarget is neither *undefined* nor the active function, then
+ 1. Return OrdinaryCreateFromConstructor(NewTarget, `"%ObjectPrototype%"`).
+ 1. If _value_ is *null*, *undefined* or not supplied, return ObjectCreate(%ObjectPrototype%).
+ 1. Return ToObject(_value_).
+
+
+
+
+
+
+
Properties of the Object Constructor
+
The value of the [[Prototype]] internal slot of the Object constructor is the intrinsic object %FunctionPrototype%.
+
Besides the `length` property (whose value is 1), the Object constructor has the following properties:
+
+
+
+
Object.assign ( _target_, ..._sources_ )
+
The `assign` function is used to copy the values of all of the enumerable own properties from one or more source objects to a _target_ object. When the `assign` function is called, the following steps are taken:
+
+ 1. Let _to_ be ? ToObject(_target_).
+ 1. If only one argument was passed, return _to_.
+ 1. Let _sources_ be the List of argument values starting with the second argument.
+ 1. For each element _nextSource_ of _sources_, in ascending index order,
+ 1. If _nextSource_ is *undefined* or *null*, let _keys_ be an empty List.
+ 1. Else,
+ 1. Let _from_ be ToObject(_nextSource_).
+ 1. Let _keys_ be ? _from_.[[OwnPropertyKeys]]().
+ 1. Repeat for each element _nextKey_ of _keys_ in List order,
+ 1. Let _desc_ be ? _from_.[[GetOwnProperty]](_nextKey_).
+ 1. If _desc_ is not *undefined* and _desc_.[[Enumerable]] is *true*, then
+ 1. Let _propValue_ be ? Get(_from_, _nextKey_).
+ 1. Let _status_ be ? Set(_to_, _nextKey_, _propValue_, *true*).
+ 1. Return _to_.
+
+
The `length` property of the `assign` method is 2.
+
+
+
+
+
Object.create ( _O_ [ , _Properties_ ] )
+
The `create` function creates a new object with a specified prototype. When the `create` function is called, the following steps are taken:
+
+ 1. If Type(_O_) is neither Object nor Null, throw a *TypeError* exception.
+ 1. Let _obj_ be ObjectCreate(_O_).
+ 1. If the argument _Properties_ is present and not *undefined*, then
+ 1. Return ObjectDefineProperties(_obj_, _Properties_).
+ 1. Return _obj_.
+
+
+
+
+
+
Object.defineProperties ( _O_, _Properties_ )
+
The `defineProperties` function is used to add own properties and/or update the attributes of existing own properties of an object. When the `defineProperties` function is called, the following steps are taken:
The abstract operation ObjectDefineProperties with arguments _O_ and _Properties_ performs the following steps:
+
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. Let _props_ be ? ToObject(_Properties_).
+ 1. Let _keys_ be ? _props_.[[OwnPropertyKeys]]().
+ 1. Let _descriptors_ be an empty List.
+ 1. Repeat for each element _nextKey_ of _keys_ in List order,
+ 1. Let _propDesc_ be ? _props_.[[GetOwnProperty]](_nextKey_).
+ 1. If _propDesc_ is not *undefined* and _propDesc_.[[Enumerable]] is *true*, then
+ 1. Let _descObj_ be ? Get( _props_, _nextKey_).
+ 1. Let _desc_ be ? ToPropertyDescriptor(_descObj_).
+ 1. Append the pair (a two element List) consisting of _nextKey_ and _desc_ to the end of _descriptors_.
+ 1. For each _pair_ from _descriptors_ in list order,
+ 1. Let _P_ be the first element of _pair_.
+ 1. Let _desc_ be the second element of _pair_.
+ 1. Let _status_ be ? DefinePropertyOrThrow(_O_,_P_, _desc_).
+ 1. Return _O_.
+
+
+
+
+
+
+
Object.defineProperty ( _O_, _P_, _Attributes_ )
+
The `defineProperty` function is used to add an own property and/or update the attributes of an existing own property of an object. When the `defineProperty` function is called, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_P_).
+ 1. Let _desc_ be ? ToPropertyDescriptor(_Attributes_).
+ 1. Let _success_ be ? DefinePropertyOrThrow(_O_,_key_, _desc_).
+ 1. Return _O_.
+
+
+
+
+
+
Object.freeze ( _O_ )
+
When the `freeze` function is called, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, return _O_.
+ 1. Let _status_ be ? SetIntegrityLevel( _O_, `"frozen"`).
+ 1. If _status_ is *false*, throw a *TypeError* exception.
+ 1. Return _O_.
+
+
+
+
+
+
Object.getOwnPropertyDescriptor ( _O_, _P_ )
+
When the `getOwnPropertyDescriptor` function is called, the following steps are taken:
+
+ 1. Let _obj_ be ? ToObject(_O_).
+ 1. Let _key_ be ? ToPropertyKey(_P_).
+ 1. Let _desc_ be ? _obj_.[[GetOwnProperty]](_key_).
+ 1. Return FromPropertyDescriptor(_desc_).
+
+
+
+
+
+
Object.getOwnPropertyNames ( _O_ )
+
When the `getOwnPropertyNames` function is called, the following steps are taken:
The abstract operation GetOwnPropertyKeys is called with arguments _O_ and _Type_ where _O_ is an Object and _Type_ is one of the ECMAScript specification types String or Symbol. The following steps are taken:
+
+ 1. Let _obj_ be ? ToObject(_O_).
+ 1. Let _keys_ be ? _obj_.[[OwnPropertyKeys]]().
+ 1. Let _nameList_ be a new empty List.
+ 1. Repeat for each element _nextKey_ of _keys_ in List order,
+ 1. If Type(_nextKey_) is _Type_, then
+ 1. Append _nextKey_ as the last element of _nameList_.
+ 1. Return CreateArrayFromList(_nameList_).
+
+
+
+
+
+
+
Object.getPrototypeOf ( _O_ )
+
When the `getPrototypeOf` function is called with argument _O_, the following steps are taken:
+
+ 1. Let _obj_ be ? ToObject(_O_).
+ 1. Return _obj_.[[GetPrototypeOf]]().
+
+
+
+
+
+
Object.is ( _value1_, _value2_ )
+
When the `is` function is called with arguments _value1_ and _value2_ the following steps are taken:
When the `isExtensible` function is called with argument _O_, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, return *false*.
+ 1. Return IsExtensible(_O_).
+
+
+
+
+
+
Object.isFrozen ( _O_ )
+
When the `isFrozen` function is called with argument _O_, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, return *true*.
+ 1. Return TestIntegrityLevel(_O_, `"frozen"`).
+
+
+
+
+
+
Object.isSealed ( _O_ )
+
When the `isSealed` function is called with argument _O_, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, return *true*.
+ 1. Return TestIntegrityLevel(_O_, `"sealed"`).
+
+
+
+
+
+
Object.keys ( _O_ )
+
When the `keys` function is called with argument _O_, the following steps are taken:
+
+ 1. Let _obj_ be ? ToObject(_O_).
+ 1. Let _nameList_ be ? EnumerableOwnNames(_obj_).
+ 1. Return CreateArrayFromList(_nameList_).
+
+
If an implementation defines a specific order of enumeration for the for-in statement, the same order must be used for the elements of the array returned in step 3.
+
+
+
+
+
Object.preventExtensions ( _O_ )
+
When the `preventExtensions` function is called, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, return _O_.
+ 1. Let _status_ be ? _O_.[[PreventExtensions]]().
+ 1. If _status_ is *false*, throw a *TypeError* exception.
+ 1. Return _O_.
+
+
+
+
+
+
Object.prototype
+
The initial value of `Object.prototype` is the intrinsic object %ObjectPrototype% ().
+
This property has the attributes {[[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Object.seal ( _O_ )
+
When the `seal` function is called, the following steps are taken:
+
+ 1. If Type(_O_) is not Object, return _O_.
+ 1. Let _status_ be ? SetIntegrityLevel( _O_, `"sealed"`).
+ 1. If _status_ is *false*, throw a *TypeError* exception.
+ 1. Return _O_.
+
+
+
+
+
+
Object.setPrototypeOf ( _O_, _proto_ )
+
When the `setPrototypeOf` function is called with arguments _O_ and proto, the following steps are taken:
+
+ 1. Let _O_ be ? RequireObjectCoercible(_O_).
+ 1. If Type(_proto_) is neither Object nor Null, throw a *TypeError* exception.
+ 1. If Type(_O_) is not Object, return _O_.
+ 1. Let _status_ be ? _O_.[[SetPrototypeOf]](_proto_).
+ 1. If _status_ is *false*, throw a *TypeError* exception.
+ 1. Return _O_.
+
+
+
+
+
+
+
Properties of the Object Prototype Object
+
The Object prototype object is the intrinsic object %ObjectPrototype%. The Object prototype object is an ordinary object.
+
The value of the [[Prototype]] internal slot of the Object prototype object is *null* and the initial value of the [[Extensible]] internal slot is *true*.
+
+
+
+
Object.prototype.constructor
+
The initial value of `Object.prototype.constructor` is the intrinsic object %Object%.
+
+
+
+
+
Object.prototype.hasOwnProperty ( _V_ )
+
When the `hasOwnProperty` method is called with argument _V_, the following steps are taken:
+
+ 1. Let _P_ be ? ToPropertyKey(_V_).
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Return HasOwnProperty(_O_, _P_).
+
+
+
The ordering of steps 1 and 2 is chosen to ensure that any exception that would have been thrown by step 1 in previous editions of this specification will continue to be thrown even if the *this* value is *undefined* or *null*.
+
+
+
+
+
+
Object.prototype.isPrototypeOf ( _V_ )
+
When the `isPrototypeOf` method is called with argument _V_, the following steps are taken:
+
+ 1. If Type(_V_) is not Object, return *false*.
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Repeat
+ 1. Let _V_ be ? _V_.[[GetPrototypeOf]]().
+ 1. If _V_ is *null*, return *false*
+ 1. If SameValue(_O_, _V_) is *true*, return *true*.
+
+
+
The ordering of steps 1 and 2 preserves the behaviour specified by previous editions of this specification for the case where _V_ is not an object and the *this* value is *undefined* or *null*.
+
+
+
+
+
+
Object.prototype.propertyIsEnumerable ( _V_ )
+
When the `propertyIsEnumerable` method is called with argument _V_, the following steps are taken:
+
+ 1. Let _P_ be ? ToPropertyKey(_V_).
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _desc_ be ? _O_.[[GetOwnProperty]](_P_).
+ 1. If _desc_ is *undefined*, return *false*.
+ 1. Return the value of _desc_.[[Enumerable]].
+
+
+
This method does not consider objects in the prototype chain.
+
+
+
The ordering of steps 1 and 2 is chosen to ensure that any exception that would have been thrown by step 1 in previous editions of this specification will continue to be thrown even if the *this* value is *undefined* or *null*.
When the `toLocaleString` method is called, the following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Return Invoke(_O_, `"toString"`).
+
+
The optional parameters to this function are not used but are intended to correspond to the parameter pattern used by ECMA-402 `toLocalString` functions. Implementations that do not include ECMA-402 support must not use those parameter positions for other purposes.
+
The `length` property of the `toLocaleString` method is 0.
+
+
This function provides a generic `toLocaleString` implementation for objects that have no locale-specific `toString` behaviour. `Array`, `Number`, `Date`, and `Typed Arrays` provide their own locale-sensitive `toLocaleString` methods.
+
+
+
ECMA-402 intentionally does not provide an alternative to this default implementation.
+
+
+
+
+
+
Object.prototype.toString ( )
+
When the `toString` method is called, the following steps are taken:
+
+ 1. If the *this* value is *undefined*, return `"[object Undefined]"`.
+ 1. If the *this* value is *null*, return `"[object Null]"`.
+ 1. Let _O_ be ToObject(*this* value).
+ 1. Let _isArray_ be ? IsArray(_O_).
+ 1. If _isArray_ is *true*, let _builtinTag_ be `"Array"`.
+ 1. Else, if _O_ is an exotic String object, let _builtinTag_ be `"String"`.
+ 1. Else, if _O_ has an [[ParameterMap]] internal slot, let _builtinTag_ be `"Arguments"`.
+ 1. Else, if _O_ has a [[Call]] internal method, let _builtinTag_ be `"Function"`.
+ 1. Else, if _O_ has an [[ErrorData]] internal slot, let _builtinTag_ be `"Error"`.
+ 1. Else, if _O_ has a [[BooleanData]] internal slot, let _builtinTag_ be `"Boolean"`.
+ 1. Else, if _O_ has a [[NumberData]] internal slot, let _builtinTag_ be `"Number"`.
+ 1. Else, if _O_ has a [[DateValue]] internal slot, let _builtinTag_ be `"Date"`.
+ 1. Else, if _O_ has a [[RegExpMatcher]] internal slot, let _builtinTag_ be `"RegExp"`.
+ 1. Else, let _builtinTag_ be `"Object"`.
+ 1. Let _tag_ be ? Get(_O_, @@toStringTag).
+ 1. If Type(_tag_) is not String, let _tag_ be _builtinTag_.
+ 1. Return the String that is the result of concatenating `"[object "`, _tag_, and `"]"`.
+
+
This function is the %ObjProto_toString% intrinsic object.
+
+
Historically, this function was occasionally used to access the String value of the [[Class]] internal slot that was used in previous editions of this specification as a nominal type tag for various built-in objects. The above definition of `toString` preserves compatibility for legacy code that uses `toString` as a test for those specific kinds of built-in objects. It does not provide a reliable type testing mechanism for other kinds of built-in or program defined objects. In addition, programs can use @@toStringTag in ways that will invalidate the reliability of such legacy type tests.
+
+
+
+
+
+
Object.prototype.valueOf ( )
+
When the `valueOf` method is called, the following steps are taken:
Object instances have no special properties beyond those inherited from the Object prototype object.
+
+
+
+
+
+
Function Objects
+
+
+
+
The Function Constructor
+
The Function constructor is the %Function% intrinsic object and the initial value of the `Function` property of the global object. When `Function` is called as a function rather than as a constructor, it creates and initializes a new Function object. Thus the function call `Function(…)` is equivalent to the object creation expression `new Function(…)` with the same arguments.
+
The `Function` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Function` behaviour must include a `super` call to the `Function` constructor to create and initialize a subclass instances with the internal slots necessary for built-in function behaviour. All ECMAScript syntactic forms for defining function objects create instances of `Function`. There is no syntactic means to create instances of `Function` subclasses except for the built-in Generator Function subclass.
+
+
+
+
Function ( _p1_, _p2_, … , _pn_, _body_ )
+
The last argument specifies the body (executable code) of a function; any preceding arguments specify formal parameters.
+
When the `Function` function is called with some arguments _p1_, _p2_, … , _pn_, _body_ (where _n_ might be 0, that is, there are no “_p_” arguments, and where _body_ might also not be provided), the following steps are taken:
+
+ 1. Let _C_ be the active function object.
+ 1. Let _args_ be the _argumentsList_ that was passed to this function by [[Call]] or [[Construct]].
+ 1. Return CreateDynamicFunction(_C_, NewTarget, `"normal"`, _args_).
+
+
+
It is permissible but not necessary to have one argument for each formal parameter to be specified. For example, all three of the following expressions produce the same result:
The abstract operation CreateDynamicFunction is called with arguments _constructor_, _newTarget_, _kind_, and _args_. _constructor_ is the constructor function that is performing this action, _newTarget_ is the constructor that `new` was initially applied to, _kind_ is either `"normal"` or `"generator"`, and _args_ is a List containing the actual argument values that were passed to _constructor_. The following steps are taken:
+
+ 1. If _newTarget_ is *undefined*, let _newTarget_ be _constructor_.
+ 1. If _kind_ is `"normal"`, then
+ 1. Let _goal_ be the grammar symbol |FunctionBody|.
+ 1. Let _parameterGoal_ be the grammar symbol |FormalParameters|.
+ 1. Let _fallbackProto_ be `"%FunctionPrototype%"`.
+ 1. Else,
+ 1. Let _goal_ be the grammar symbol |GeneratorBody|.
+ 1. Let _parameterGoal_ be the grammar symbol |FormalParameters[Yield]|.
+ 1. Let _fallbackProto_ be `"%Generator%"`.
+ 1. Let _argCount_ be the number of elements in _args_.
+ 1. Let _P_ be the empty String.
+ 1. If _argCount_ = 0, let _bodyText_ be the empty String.
+ 1. Else if _argCount_ = 1, let _bodyText_ be _args_[0].
+ 1. Else _argCount_ > 1,
+ 1. Let _firstArg_ be _args_[0].
+ 1. Let _P_ be ? ToString(_firstArg_).
+ 1. Let _k_ be 1.
+ 1. Repeat, while _k_ < _argCount_-1
+ 1. Let _nextArg_ be _args_[_k_].
+ 1. Let _nextArgString_ be ? ToString(_nextArg_).
+ 1. Let _P_ be the result of concatenating the previous value of _P_, the String `","` (a comma), and _nextArgString_.
+ 1. Increase _k_ by 1.
+ 1. Let _bodyText_ be _args_[_k_].
+ 1. Let _bodyText_ be ? ToString(_bodyText_).
+ 1. Let _parameters_ be the result of parsing _P_, interpreted as UTF-16 encoded Unicode text as described in , using _parameterGoal_ as the goal symbol. Throw a *SyntaxError* exception if the parse fails.
+ 1. Let _body_ be the result of parsing _bodyText_, interpreted as UTF-16 encoded Unicode text as described in , using _goal_ as the goal symbol. Throw a *SyntaxError* exception if the parse fails.
+ 1. If _bodyText_ is strict mode code (see ) then let _strict_ be *true*, else let _strict_ be *false*.
+ 1. If any static semantics errors are detected for _parameters_ or _body_, throw a *SyntaxError* or a *ReferenceError* exception, depending on the type of the error. If _strict_ is *true*, the Early Error rules for StrictFormalParameters : FormalParameters are applied. Parsing and early error detection may be interweaved in an implementation dependent manner.
+ 1. If ContainsUseStrict of _body_ is *true* and IsSimpleParameterList of _parameters_ is *false*, throw a *SyntaxError* exception.
+ 1. If any element of the BoundNames of _parameters_ also occurs in the LexicallyDeclaredNames of _body_, throw a *SyntaxError* exception.
+ 1. If _body_ Contains |SuperCall| is *true*, throw a *SyntaxError* exception.
+ 1. If _parameters_ Contains |SuperCall| is *true*, throw a *SyntaxError* exception.
+ 1. If _body_ Contains |SuperProperty| is *true*, throw a *SyntaxError* exception.
+ 1. If _parameters_ Contains |SuperProperty| is *true*, throw a *SyntaxError* exception.
+ 1. If _kind_ is `"generator"`, then
+ 1. If _parameters_ Contains |YieldExpression| is *true*, throw a *SyntaxError* exception.
+ 1. If _strict_ is *true*, then
+ 1. If BoundNames of _parameters_ contains any duplicate elements, throw a *SyntaxError* exception.
+ 1. Let _proto_ be ? GetPrototypeFromConstructor(_newTarget_, _fallbackProto_).
+ 1. Let _F_ be FunctionAllocate(_proto_, _strict_, _kind_).
+ 1. Let _realmF_ be the value of _F_'s [[Realm]] internal slot.
+ 1. Let _scope_ be _realmF_.[[globalEnv]].
+ 1. Perform FunctionInitialize(_F_, ~Normal~, _parameters_, _body_, _scope_).
+ 1. If _kind_ is `"generator"`, then
+ 1. Let _prototype_ be ObjectCreate(%GeneratorPrototype%).
+ 1. Perform DefinePropertyOrThrow(_F_, `"prototype"`, PropertyDescriptor{[[Value]]: _prototype_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Else, perform MakeConstructor(_F_).
+ 1. Perform SetFunctionName(_F_, `"anonymous"`).
+ 1. Return _F_.
+
+
+
A `prototype` property is automatically created for every function created using CreateDynamicFunction , to provide for the possibility that the function will be used as a constructor.
+
+
+
+
+
+
+
+
Properties of the Function Constructor
+
The `Function` constructor is itself a built-in function object. The value of the [[Prototype]] internal slot of the `Function` constructor is %FunctionPrototype%, the intrinsic Function prototype object ().
+
The value of the [[Extensible]] internal slot of the Function constructor is *true*.
+
The Function constructor has the following properties:
+
+
+
+
Function.length
+
This is a data property with a value of 1. This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
Function.prototype
+
The value of `Function.prototype` is %FunctionPrototype%, the intrinsic Function prototype object ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the Function Prototype Object
+
The Function prototype object is the intrinsic object %FunctionPrototype%. The Function prototype object is itself a built-in function object. When invoked, it accepts any arguments and returns *undefined*. It does not have a [[Construct]] internal method so it is not a constructor.
+
+
The Function prototype object is specified to be a function object to ensure compatibility with ECMAScript code that was created prior to the ECMAScript 2015 specification.
+
+
The value of the [[Prototype]] internal slot of the Function prototype object is the intrinsic object %ObjectPrototype% (). The initial value of the [[Extensible]] internal slot of the Function prototype object is *true*.
+
The Function prototype object does not have a `prototype` property.
+
The value of the `length` property of the Function prototype object is 0.
+
The value of the `name` property of the Function prototype object is the empty String.
When the `apply` method is called on an object _func_ with arguments _thisArg_ and _argArray_, the following steps are taken:
+
+ 1. If IsCallable(_func_) is *false*, throw a *TypeError* exception.
+ 1. If _argArray_ is *null* or *undefined*, then
+ 1. Perform PrepareForTailCall().
+ 1. Return Call(_func_, _thisArg_).
+ 1. Let _argList_ be ? CreateListFromArrayLike(_argArray_).
+ 1. Perform PrepareForTailCall().
+ 1. Return Call(_func_, _thisArg_, _argList_).
+
+
+
The thisArg value is passed without modification as the *this* value. This is a change from Edition 3, where an *undefined* or *null* thisArg is replaced with the global object and ToObject is applied to all other values and that result is passed as the *this* value. Even though the thisArg is passed without modification, non-strict functions still perform these transformations upon entry to the function.
+
+
+
If _func_ is an arrow function or a bound function then the _thisArg_ will be ignored by the function [[Call]] in step 5.
+
+
+
+
+
+
Function.prototype.bind ( _thisArg_ , ..._args_)
+
When the `bind` method is called with argument _thisArg_ and zero or more _args_, it performs the following steps:
+
+ 1. Let _Target_ be the *this* value.
+ 1. If IsCallable(_Target_) is *false*, throw a *TypeError* exception.
+ 1. Let _args_ be a new (possibly empty) List consisting of all of the argument values provided after _thisArg_ in order.
+ 1. Let _F_ be ? BoundFunctionCreate(_Target_, _thisArg_, _args_).
+ 1. Let _targetHasLength_ be ? HasOwnProperty(_Target_, `"length"`).
+ 1. If _targetHasLength_ is *true*, then
+ 1. Let _targetLen_ be ? Get(_Target_, `"length"`).
+ 1. If Type(_targetLen_) is not Number, let _L_ be 0.
+ 1. Else,
+ 1. Let _targetLen_ be ToInteger(_targetLen_).
+ 1. Let _L_ be the larger of 0 and the result of _targetLen_ minus the number of elements of _args_.
+ 1. Else let _L_ be 0.
+ 1. Let _status_ be DefinePropertyOrThrow(_F_, `"length"`, PropertyDescriptor {[[Value]]: _L_, [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true*}).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Let _targetName_ be ? Get(_Target_, `"name"`).
+ 1. If Type(_targetName_) is not String, let _targetName_ be the empty string.
+ 1. Perform SetFunctionName(_F_, _targetName_, `"bound"`).
+ 1. Return _F_.
+
+
The `length` property of the `bind` method is 1.
+
+
Function objects created using `Function.prototype.bind` are exotic objects. They also do not have a `prototype` property.
+
+
+
If _Target_ is an arrow function or a bound function then the _thisArg_ passed to this method will not be used by subsequent calls to _F_.
+
+
+
+
+
+
Function.prototype.call (_thisArg_ , ..._args_)
+
When the `call` method is called on an object _func_ with argument, _thisArg_ and zero or more _args_, the following steps are taken:
+
+ 1. If IsCallable(_func_) is *false*, throw a *TypeError* exception.
+ 1. Let _argList_ be an empty List.
+ 1. If this method was called with more than one argument then in left to right order, starting with the second argument, append each argument as the last element of _argList_.
+ 1. Perform PrepareForTailCall().
+ 1. Return Call(_func_, _thisArg_, _argList_).
+
+
The `length` property of the `call` method is 1.
+
+
The thisArg value is passed without modification as the *this* value. This is a change from Edition 3, where an *undefined* or *null* thisArg is replaced with the global object and ToObject is applied to all other values and that result is passed as the *this* value. Even though the thisArg is passed without modification, non-strict functions still perform these transformations upon entry to the function.
+
+
+
If _func_ is an arrow function or a bound function then the _thisArg_ will be ignored by the function [[Call]] in step 5.
+
+
+
+
+
+
Function.prototype.constructor
+
The initial value of `Function.prototype.constructor` is the intrinsic object %Function%.
+
+
+
+
+
Function.prototype.toString ( )
+
When the `toString` method is called on an object _func_ the following steps are taken:
+
+ 1. If _func_ is a Bound Function exotic object, then
+ 1. Return an implementation-dependent String source code representation of _func_. The representation must conform to the rules below. It is implementation dependent whether the representation includes bound function information or information about the target function.
+ 1. If Type(_func_) is Object and is either a built-in function object or has an [[ECMAScriptCode]] internal slot, then
+ 1. Return an implementation-dependent String source code representation of _func_. The representation must conform to the rules below.
+ 1. Throw a *TypeError* exception.
+
+
`toString` Representation Requirements:
+
+
+ The string representation must have the syntax of a |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |ClassDeclaration|, |ClassExpression|, |ArrowFunction|, |MethodDefinition|, or |GeneratorMethod| depending upon the actual characteristics of the object.
+
+
+ The use and placement of white space, line terminators, and semicolons within the representation String is implementation-dependent.
+
+
+ If the object was defined using ECMAScript code and the returned string representation is not in the form of a |MethodDefinition| or |GeneratorMethod| then the representation must be such that if the string is evaluated, using `eval` in a lexical context that is equivalent to the lexical context used to create the original object, it will result in a new functionally equivalent object. In that case the returned source code must not mention freely any variables that were not mentioned freely by the original function's source code, even if these “extra” names were originally in scope.
+
+
+ If the implementation cannot produce a source code string that meets these criteria then it must return a string for which `eval` will throw a *SyntaxError* exception.
+
+
+
+
+
+
+
Function.prototype[@@hasInstance] ( _V_ )
+
When the @@hasInstance method of an object _F_ is called with value _V_, the following steps are taken:
+
+ 1. Let _F_ be the *this* value.
+ 1. Return OrdinaryHasInstance(_F_, _V_).
+
+
The value of the `name` property of this function is `"[Symbol.hasInstance]"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
This is the default implementation of `@@hasInstance` that most functions inherit. `@@hasInstance` is called by the `instanceof` operator to determine whether a value is an instance of a specific constructor. An expression such as
+
+ v instanceof F
+
+
evaluates as
+
+ F[@@hasInstance](v)
+
+
A constructor function can control which objects are recognized as its instances by `instanceof` by exposing a different `@@hasInstance` method on the function.
+
+
This property is non-writable and non-configurable to prevent tampering that could be used to globally expose the target function of a bound function.
+
+
+
+
+
+
Function Instances
+
Every function instance is an ECMAScript function object and has the internal slots listed in . Function instances created using the `Function.prototype.bind` method () have the internal slots listed in .
+
The Function instances have the following properties:
+
+
+
+
length
+
The value of the `length` property is an integer that indicates the typical number of arguments expected by the function. However, the language permits the function to be invoked with some other number of arguments. The behaviour of a function when invoked on a number of arguments other than the number specified by its `length` property depends on the function. This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
name
+
The value of the `name` property is an String that is descriptive of the function. The name has no semantic significance but is typically a variable or property name that is used to refer to the function at its point of definition in ECMAScript code. This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
Anonymous functions objects that do not have a contextual name associated with them by this specification do not have a `name` own property but inherit the `name` property of %FunctionPrototype%.
+
+
+
+
+
prototype
+
Function instances that can be used as a constructor have a `prototype` property. Whenever such a function instance is created another ordinary object is also created and is the initial value of the function's `prototype` property. Unless otherwise specified, the value of the `prototype` property is used to initialize the [[Prototype]] internal slot of the object created when that function is invoked as a constructor.
+
This property has the attributes { [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
Function objects created using `Function.prototype.bind`, or by evaluating a |MethodDefinition| (that are not a |GeneratorMethod|) or an |ArrowFunction| grammar production do not have a `prototype` property.
+
+
+
+
+
+
+
+
Boolean Objects
+
+
+
+
The Boolean Constructor
+
The Boolean constructor is the %Boolean% intrinsic object and the initial value of the `Boolean` property of the global object. When called as a constructor it creates and initializes a new Boolean object. When `Boolean` is called as a function rather than as a constructor, it performs a type conversion.
+
The `Boolean` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Boolean` behaviour must include a `super` call to the `Boolean` constructor to create and initialize the subclass instance with a [[BooleanData]] internal slot.
+
+
+
+
Boolean ( _value_ )
+
When `Boolean` is called with argument _value_, the following steps are taken:
+
+ 1. Let _b_ be ToBoolean(_value_).
+ 1. If NewTarget is *undefined*, return _b_.
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%BooleanPrototype%"`, « [[BooleanData]] » ).
+ 1. Set the value of _O_'s [[BooleanData]] internal slot to _b_.
+ 1. Return _O_.
+
+
+
+
+
+
+
Properties of the Boolean Constructor
+
The value of the [[Prototype]] internal slot of the Boolean constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 1), the Boolean constructor has the following properties:
+
+
+
+
Boolean.prototype
+
The initial value of `Boolean.prototype` is the intrinsic object %BooleanPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the Boolean Prototype Object
+
The Boolean prototype object is the intrinsic object %BooleanPrototype%. The Boolean prototype object is an ordinary object. The Boolean prototype is itself a Boolean object; it has a [[BooleanData]] internal slot with the value *false*.
+
The value of the [[Prototype]] internal slot of the Boolean prototype object is the intrinsic object %ObjectPrototype% ().
+
The abstract operation thisBooleanValue(_value_) performs the following steps:
+
+ 1. If Type(_value_) is Boolean, return _value_.
+ 1. If Type(_value_) is Object and _value_ has a [[BooleanData]] internal slot, then
+ 1. Assert: _value_'s [[BooleanData]] internal slot is a Boolean value.
+ 1. Return the value of _value_'s [[BooleanData]] internal slot.
+ 1. Throw a *TypeError* exception.
+
+
+
+
+
Boolean.prototype.constructor
+
The initial value of `Boolean.prototype.constructor` is the intrinsic object %Boolean%.
+
+
+
+
+
Boolean.prototype.toString ( )
+
The following steps are taken:
+
+ 1. Let _b_ be ? thisBooleanValue(*this* value).
+ 1. If _b_ is *true*, return `"true"`; else return `"false"`.
+
+
+
+
+
+
Boolean instances are ordinary objects that inherit properties from the Boolean prototype object. Boolean instances have a [[BooleanData]] internal slot. The [[BooleanData]] internal slot is the Boolean value represented by this Boolean object.
+
+
+
+
+
+
Symbol Objects
+
+
+
+
The Symbol Constructor
+
The Symbol constructor is the %Symbol% intrinsic object and the initial value of the `Symbol` property of the global object. When `Symbol` is called as a function, it returns a new Symbol value.
+
The `Symbol` constructor is not intended to be used with the `new` operator or to be subclassed. It may be used as the value of an `extends` clause of a class definition but a `super` call to the `Symbol` constructor will cause an exception.
+
+
+
+
Symbol ( [ _description_ ] )
+
When `Symbol` is called with optional argument _description_, the following steps are taken:
+
+ 1. If NewTarget is not *undefined*, throw a *TypeError* exception.
+ 1. If _description_ is *undefined*, let _descString_ be *undefined*.
+ 1. Else, let _descString_ be ? ToString(_description_).
+ 1. Return a new unique Symbol value whose [[Description]] value is _descString_.
+
+
+
+
+
+
+
Properties of the Symbol Constructor
+
The value of the [[Prototype]] internal slot of the Symbol constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 0), the Symbol constructor has the following properties:
+
+
+
+
Symbol.for ( _key_ )
+
When `Symbol.for` is called with argument _key_ it performs the following steps:
+
+ 1. Let _stringKey_ be ? ToString(_key_).
+ 1. For each element _e_ of the GlobalSymbolRegistry List,
+ 1. If SameValue(_e_.[[key]], _stringKey_) is *true*, return _e_.[[symbol]].
+ 1. Assert: GlobalSymbolRegistry does not currently contain an entry for _stringKey_.
+ 1. Let _newSymbol_ be a new unique Symbol value whose [[Description]] value is _stringKey_.
+ 1. Append the record { [[key]]: _stringKey_, [[symbol]]: _newSymbol_ } to the GlobalSymbolRegistry List.
+ 1. Return _newSymbol_.
+
+
The GlobalSymbolRegistry is a List that is globally available. It is shared by all Code Realms. Prior to the evaluation of any ECMAScript code it is initialized as an empty List. Elements of the GlobalSymbolRegistry are Records with the structure defined in .
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Usage
+
+
+
+
+ [[key]]
+
+
+ A String
+
+
+ A string key used to globally identify a Symbol.
+
+
+
+
+ [[symbol]]
+
+
+ A Symbol
+
+
+ A symbol that can be retrieved from any Realm.
+
+
+
+
+
+
+
+
+
+
Symbol.hasInstance
+
The initial value of `Symbol.hasInstance` is the well known symbol @@hasInstance ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.isConcatSpreadable
+
The initial value of `Symbol.isConcatSpreadable` is the well known symbol @@isConcatSpreadable ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.iterator
+
The initial value of `Symbol.iterator` is the well known symbol @@iterator ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.keyFor ( _sym_ )
+
When `Symbol.keyFor` is called with argument _sym_ it performs the following steps:
+
+ 1. If Type(_sym_) is not Symbol, throw a *TypeError* exception.
+ 1. For each element _e_ of the GlobalSymbolRegistry List (see ),
+ 1. If SameValue(_e_.[[symbol]], _sym_) is *true*, return _e_.[[key]].
+ 1. Assert: GlobalSymbolRegistry does not currently contain an entry for _sym_.
+ 1. Return *undefined*.
+
+
+
+
+
+
Symbol.match
+
The initial value of `Symbol.match` is the well known symbol @@match ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.prototype
+
The initial value of `Symbol.prototype` is the intrinsic object %SymbolPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.replace
+
The initial value of `Symbol.replace` is the well known symbol @@replace ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.search
+
The initial value of `Symbol.search` is the well known symbol @@search ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.species
+
The initial value of `Symbol.species` is the well known symbol @@species ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.split
+
The initial value of `Symbol.split` is the well known symbol @@split ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.toPrimitive
+
The initial value of `Symbol.toPrimitive` is the well known symbol @@toPrimitive ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.toStringTag
+
The initial value of `Symbol.toStringTag` is the well known symbol @@toStringTag ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Symbol.unscopables
+
The initial value of `Symbol.unscopables` is the well known symbol @@unscopables ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the Symbol Prototype Object
+
The Symbol prototype object is the intrinsic object %SymbolPrototype%. The Symbol prototype object is an ordinary object. It is not a Symbol instance and does not have a [[SymbolData]] internal slot.
+
The value of the [[Prototype]] internal slot of the Symbol prototype object is the intrinsic object %ObjectPrototype% ().
+
+
+
+
Symbol.prototype.constructor
+
The initial value of `Symbol.prototype.constructor` is the intrinsic object %Symbol%.
+
+
+
+
+
Symbol.prototype.toString ( )
+
The following steps are taken:
+
+ 1. Let _s_ be the *this* value.
+ 1. If Type(_s_) is Symbol, let _sym_ be _s_.
+ 1. Else,
+ 1. If Type(_s_) is not Object, throw a *TypeError* exception.
+ 1. If _s_ does not have a [[SymbolData]] internal slot, throw a *TypeError* exception.
+ 1. Let _sym_ be the value of _s_'s [[SymbolData]] internal slot.
+ 1. Return SymbolDescriptiveString(_sym_).
+
+
+
+
+
When the abstract operation SymbolDescriptiveString is called with argument _sym_, the following steps are taken:
+
+ 1. Assert: Type(_sym_) is Symbol.
+ 1. Let _desc_ be _sym_'s [[Description]] value.
+ 1. If _desc_ is *undefined*, let _desc_ be the empty string.
+ 1. Assert: Type(_desc_) is String.
+ 1. Return the result of concatenating the strings `"Symbol("`, _desc_, and `")"`.
+
+
+
+
+
+
+
Symbol.prototype.valueOf ( )
+
The following steps are taken:
+
+ 1. Let _s_ be the *this* value.
+ 1. If Type(_s_) is Symbol, return _s_.
+ 1. If Type(_s_) is not Object, throw a *TypeError* exception.
+ 1. If _s_ does not have a [[SymbolData]] internal slot, throw a *TypeError* exception.
+ 1. Return the value of _s_'s [[SymbolData]] internal slot.
+
+
+
+
+
+
Symbol.prototype [ @@toPrimitive ] ( _hint_ )
+
This function is called by ECMAScript language operators to convert a Symbol object to a primitive value. The allowed values for _hint_ are `"default"`, `"number"`, and `"string"`.
+
When the `@@toPrimitive` method is called with argument _hint_, the following steps are taken:
+
+ 1. Let _s_ be the *this* value.
+ 1. If Type(_s_) is Symbol, return _s_.
+ 1. If Type(_s_) is not Object, throw a *TypeError* exception.
+ 1. If _s_ does not have a [[SymbolData]] internal slot, throw a *TypeError* exception.
+ 1. Return the value of _s_'s [[SymbolData]] internal slot.
+
+
The value of the `name` property of this function is `"[Symbol.toPrimitive]"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
Symbol.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Symbol"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Symbol Instances
+
Symbol instances are ordinary objects that inherit properties from the Symbol prototype object. Symbol instances have a [[SymbolData]] internal slot. The [[SymbolData]] internal slot is the Symbol value represented by this Symbol object.
+
+
+
+
+
+
Error Objects
+
Instances of Error objects are thrown as exceptions when runtime errors occur. The Error objects may also serve as base objects for user-defined exception classes.
+
+
+
+
The Error Constructor
+
The Error constructor is the %Error% intrinsic object and the initial value of the `Error` property of the global object. When `Error` is called as a function rather than as a constructor, it creates and initializes a new Error object. Thus the function call `Error(…)` is equivalent to the object creation expression `new Error(…)` with the same arguments.
+
The `Error` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Error` behaviour must include a `super` call to the `Error` constructor to create and initialize subclass instances with a [[ErrorData]] internal slot.
+
+
+
+
Error ( _message_ )
+
When the `Error` function is called with argument _message_ the following steps are taken:
+
+ 1. If NewTarget is *undefined*, let _newTarget_ be the active function object, else let _newTarget_ be NewTarget.
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(_newTarget_, `"%ErrorPrototype%"`, « [[ErrorData]] »).
+ 1. If _message_ is not *undefined*, then
+ 1. Let _msg_ be ? ToString(_message_).
+ 1. Let _msgDesc_ be the PropertyDescriptor{[[Value]]: _msg_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}.
+ 1. Let _status_ be DefinePropertyOrThrow(_O_, `"message"`, _msgDesc_).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return _O_.
+
+
+
+
+
+
+
Properties of the Error Constructor
+
The value of the [[Prototype]] internal slot of the Error constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 1), the Error constructor has the following properties:
+
+
+
+
Error.prototype
+
The initial value of `Error.prototype` is the intrinsic object %ErrorPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the Error Prototype Object
+
The Error prototype object is the intrinsic object %ErrorPrototype%. The Error prototype object is an ordinary object. It is not an Error instance and does not have an [[ErrorData]] internal slot.
+
The value of the [[Prototype]] internal slot of the Error prototype object is the intrinsic object %ObjectPrototype% ().
+
+
+
+
Error.prototype.constructor
+
The initial value of `Error.prototype.constructor` is the intrinsic object %Error%.
+
+
+
+
+
Error.prototype.message
+
The initial value of `Error.prototype.message` is the empty String.
+
+
+
+
+
Error.prototype.name
+
The initial value of `Error.prototype.name` is `"Error"`.
+
+
+
+
+
Error.prototype.toString ( )
+
The following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. Let _name_ be ? Get(_O_, `"name"`).
+ 1. If _name_ is *undefined*, let _name_ be `"Error"`; otherwise let _name_ be ? ToString(_name_).
+ 1. Let _msg_ be ? Get(_O_, `"message"`).
+ 1. If _msg_ is *undefined*, let _msg_ be the empty String; otherwise let _msg_ be ? ToString(_msg_).
+ 1. If _name_ is the empty String, return _msg_.
+ 1. If _msg_ is the empty String, return _name_.
+ 1. Return the result of concatenating _name_, the code unit 0x003A (COLON), the code unit 0x0020 (SPACE), and _msg_.
+
+
+
+
+
+
+
Properties of Error Instances
+
Error instances are ordinary objects that inherit properties from the Error prototype object and have an [[ErrorData]] internal slot whose value is *undefined*. The only specified uses of [[ErrorData]] is to identify Error and _NativeError_ instances as Error objects within `Object.prototype.toString`.
+
+
+
+
+
Native Error Types Used in This Standard
+
A new instance of one of the _NativeError_ objects below is thrown when a runtime error is detected. All of these objects share the same structure, as described in .
+
+
+
+
EvalError
+
This exception is not currently used within this specification. This object remains for compatibility with previous editions of this specification.
+
+
+
+
+
RangeError
+
Indicates a value that is not in the set or range of allowable values.
+
+
+
+
+
ReferenceError
+
Indicate that an invalid reference value has been detected.
+
+
+
+
+
SyntaxError
+
+
+
+
+
+
TypeError
+
TypeError is used to indicate an unsuccessful operation when none of the other _NativeError_ objects are an appropriate indication of the failure cause.
+
+
+
+
+
URIError
+
Indicates that one of the global URI handling functions was used in a way that is incompatible with its definition.
+
+
+
+
+
+
_NativeError_ Object Structure
+
When an ECMAScript implementation detects a runtime error, it throws a new instance of one of the _NativeError_ objects defined in . Each of these objects has the structure described below, differing only in the name used as the constructor name instead of _NativeError_, in the `name` property of the prototype object, and in the implementation-defined `message` property of the prototype object.
+
For each error object, references to _NativeError_ in the definition should be replaced with the appropriate error object name from .
+
+
+
+
_NativeError_ Constructors
+
When a _NativeError_ constructor is called as a function rather than as a constructor, it creates and initializes a new _NativeError_ object. A call of the object as a function is equivalent to calling it as a constructor with the same arguments. Thus the function call NativeError(…) is equivalent to the object creation expression new NativeError(…) with the same arguments.
+
Each _NativeError_ constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified _NativeError_ behaviour must include a `super` call to the _NativeError_ constructor to create and initialize subclass instances with a [[ErrorData]] internal slot.
+
+
+
+
NativeError ( _message_ )
+
When a _NativeError_ function is called with argument _message_ the following steps are taken:
+
+ 1. If NewTarget is *undefined*, let _newTarget_ be the active function object, else let _newTarget_ be NewTarget.
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(_newTarget_, "%NativeErrorPrototype%", « [[ErrorData]] » ).
+ 1. If _message_ is not *undefined*, then
+ 1. Let _msg_ be ? ToString(_message_).
+ 1. Let _msgDesc_ be the PropertyDescriptor{[[Value]]: _msg_, [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *true*}.
+ 1. Let _status_ be DefinePropertyOrThrow(_O_, `"message"`, _msgDesc_).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return _O_.
+
+
The actual value of the string passed in step 2 is either `"%EvalErrorPrototype%"`, `"%RangeErrorPrototype%"`, `"%ReferenceErrorPrototype%"`, `"%SyntaxErrorPrototype%"`, `"%TypeErrorPrototype%"`, or `"%URIErrorPrototype%"` corresponding to which _NativeError_ constructor is being defined.
+
+
+
+
+
+
Properties of the _NativeError_ Constructors
+
The value of the [[Prototype]] internal slot of a _NativeError_ constructor is the intrinsic object %Error% ().
+
Besides the `length` property (whose value is 1), each _NativeError_ constructor has the following properties:
+
+
+
+
NativeError.prototype
+
The initial value of NativeError.prototype is a _NativeError_ prototype object (). Each _NativeError_ constructor has a distinct prototype object.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the _NativeError_ Prototype Objects
+
Each _NativeError_ prototype object is an ordinary object. It is not an Error instance and does not have an [[ErrorData]] internal slot.
+
The value of the [[Prototype]] internal slot of each _NativeError_ prototype object is the intrinsic object %ErrorPrototype% ().
+
+
+
+
_NativeError_.prototype.constructor
+
The initial value of the `constructor` property of the prototype for a given _NativeError_ constructor is the corresponding intrinsic object %_NativeError_% ().
+
+
+
+
+
_NativeError_.prototype.message
+
The initial value of the `message` property of the prototype for a given _NativeError_ constructor is the empty String.
+
+
+
+
+
_NativeError_.prototype.name
+
The initial value of the `name` property of the prototype for a given _NativeError_ constructor is a string consisting of the name of the constructor (the name used instead of _NativeError_).
+
+
+
+
+
+
Properties of _NativeError_ Instances
+
_NativeError_ instances are ordinary objects that inherit properties from their _NativeError_ prototype object and have an [[ErrorData]] internal slot whose value is *undefined*. The only specified use of [[ErrorData]] is by `Object.prototype.toString` () to identify Error or _NativeError_ instances.
+
+
+
+
+
+
+
+
Numbers and Dates
+
+
+
+
Number Objects
+
+
+
+
The Number Constructor
+
The Number constructor is the %Number% intrinsic object and the initial value of the `Number` property of the global object. When called as a constructor, it creates and initializes a new Number object. When `Number` is called as a function rather than as a constructor, it performs a type conversion.
+
The `Number` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Number` behaviour must include a `super` call to the `Number` constructor to create and initialize the subclass instance with a [[NumberData]] internal slot.
+
+
+
+
Number ( [ _value_ ] )
+
When `Number` is called with argument _number_, the following steps are taken:
+
+ 1. If no arguments were passed to this function invocation, let _n_ be +0.
+ 1. Else, let _n_ be ? ToNumber(_value_).
+ 1. If NewTarget is *undefined*, return _n_.
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%NumberPrototype%"`, « [[NumberData]] » ).
+ 1. Set the value of _O_'s [[NumberData]] internal slot to _n_.
+ 1. Return _O_.
+
+
+
+
+
+
+
Properties of the Number Constructor
+
The value of the [[Prototype]] internal slot of the Number constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 1), the Number constructor has the following properties:
+
+
+
+
Number.EPSILON
+
The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 that is representable as a Number value, which is approximately 2.2204460492503130808472633361816 x 10-16.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.isFinite ( _number_ )
+
When the `Number.isFinite` is called with one argument _number_, the following steps are taken:
+
+ 1. If Type(_number_) is not Number, return *false*.
+ 1. If _number_ is *NaN*, *+∞*, or *-∞*, return *false*.
+ 1. Otherwise, return *true*.
+
+
+
+
+
+
Number.isInteger ( _number_ )
+
When the `Number.isInteger` is called with one argument _number_, the following steps are taken:
+
+ 1. If Type(_number_) is not Number, return *false*.
+ 1. If _number_ is *NaN*, *+∞*, or *-∞*, return *false*.
+ 1. Let _integer_ be ToInteger(_number_).
+ 1. If _integer_ is not equal to _number_, return *false*.
+ 1. Otherwise, return *true*.
+
+
+
+
+
+
Number.isNaN ( _number_ )
+
When the `Number.isNaN` is called with one argument _number_, the following steps are taken:
+
+ 1. If Type(_number_) is not Number, return *false*.
+ 1. If _number_ is *NaN*, return *true*.
+ 1. Otherwise, return *false*.
+
+
+
This function differs from the global isNaN function () is that it does not convert its argument to a Number before determining whether it is NaN.
+
+
+
+
+
+
Number.isSafeInteger ( _number_ )
+
When the `Number.isSafeInteger` is called with one argument _number_, the following steps are taken:
+
+ 1. If Type(_number_) is not Number, return *false*.
+ 1. If _number_ is *NaN*, *+∞*, or *-∞*, return *false*.
+ 1. Let _integer_ be ToInteger(_number_).
+ 1. If _integer_ is not equal to _number_, return *false*.
+ 1. If abs(_integer_) ≤ 253-1, return *true*.
+ 1. Otherwise, return *false*.
+
+
+
+
+
+
Number.MAX_SAFE_INTEGER
+
+
The value of `Number.MAX_SAFE_INTEGER` is the largest integer n such that n and n + 1 are both exactly representable as a Number value.
+
+
The value of Number.MAX_SAFE_INTEGER is 9007199254740991 (253-1).
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.MAX_VALUE
+
The value of `Number.MAX_VALUE` is the largest positive finite value of the Number type, which is approximately 1.7976931348623157 × 10308.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.MIN_SAFE_INTEGER
+
+
The value of `Number.MIN_SAFE_INTEGER` is the smallest integer n such that n and n - 1 are both exactly representable as a Number value.
+
+
The value of Number.MIN_SAFE_INTEGER is -9007199254740991 (-(253-1)).
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.MIN_VALUE
+
The value of `Number.MIN_VALUE` is the smallest positive value of the Number type, which is approximately 5 × 10-324.
+
In the IEEE 754-2008 double precision binary representation, the smallest possible value is a denormalized number. If an implementation does not support denormalized values, the value of `Number.MIN_VALUE` must be the smallest non-zero positive value that can actually be represented by the implementation.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.NaN
+
The value of `Number.NaN` is *NaN*.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.NEGATIVE_INFINITY
+
The value of Number.NEGATIVE_INFINITY is *-∞*.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.parseFloat ( _string_ )
+
The value of the `Number.parseFloat` data property is the same built-in function object that is the value of the `parseFloat` property of the global object defined in .
+
+
+
+
+
Number.parseInt ( _string_, _radix_ )
+
The value of the `Number.parseInt` data property is the same built-in function object that is the value of the `parseInt` property of the global object defined in .
+
+
+
+
+
Number.POSITIVE_INFINITY
+
The value of Number.POSITIVE_INFINITY is *+∞*.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Number.prototype
+
The initial value of `Number.prototype` is the intrinsic object %NumberPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the Number Prototype Object
+
The Number prototype object is the intrinsic object %NumberPrototype%. The Number prototype object is an ordinary object. The Number prototype is itself a Number object; it has a [[NumberData]] internal slot with the value *+0*.
+
The value of the [[Prototype]] internal slot of the Number prototype object is the intrinsic object %ObjectPrototype% ().
+
Unless explicitly stated otherwise, the methods of the Number prototype object defined below are not generic and the *this* value passed to them must be either a Number value or an object that has a [[NumberData]] internal slot that has been initialized to a Number value.
+
The abstract operation thisNumberValue(_value_) performs the following steps:
+
+ 1. If Type(_value_) is Number, return _value_.
+ 1. If Type(_value_) is Object and _value_ has a [[NumberData]] internal slot, then
+ 1. Assert: _value_'s [[NumberData]] internal slot is a Number value.
+ 1. Return the value of _value_'s [[NumberData]] internal slot.
+ 1. Throw a *TypeError* exception.
+
+
The phrase “this Number value” within the specification of a method refers to the result returned by calling the abstract operation thisNumberValue with the *this* value of the method invocation passed as the argument.
+
+
+
+
Number.prototype.constructor
+
The initial value of `Number.prototype.constructor` is the intrinsic object %Number%.
Return a String containing this Number value represented in decimal exponential notation with one digit before the significand's decimal point and _fractionDigits_ digits after the significand's decimal point. If _fractionDigits_ is *undefined*, include as many significand digits as necessary to uniquely specify the Number (just like in ToString except that in this case the Number is always output in exponential notation). Specifically, perform the following steps:
+
+ 1. Let _x_ be ? thisNumberValue(*this* value).
+ 1. Let _f_ be ? ToInteger(_fractionDigits_).
+ 1. Assert: _f_ is 0, when _fractionDigits_ is *undefined*.
+ 1. If _x_ is *NaN*, return the String `"NaN"`.
+ 1. Let _s_ be the empty String.
+ 1. If _x_ < 0, then
+ 1. Let _s_ be `"-"`.
+ 1. Let _x_ be -_x_.
+ 1. If _x_ = *+∞*, then
+ 1. Return the concatenation of the Strings _s_ and `"Infinity"`.
+ 1. If _f_ < 0 or _f_ > 20, throw a *RangeError* exception. However, an implementation is permitted to extend the behaviour of `toExponential` for values of _f_ less than 0 or greater than 20. In this case `toExponential` would not necessarily throw *RangeError* for such values.
+ 1. If _x_ = 0, then
+ 1. Let _m_ be the String consisting of _f_+1 occurrences of the code unit 0x0030.
+ 1. Let _e_ be 0.
+ 1. Else _x_ ≠ 0,
+ 1. If _fractionDigits_ is not *undefined*, then
+ 1. Let _e_ and _n_ be integers such that 10_f_ ≤ _n_ < 10_f_+1 and for which the exact mathematical value of _n_ × 10_e_-_f_ - _x_ is as close to zero as possible. If there are two such sets of _e_ and _n_, pick the _e_ and _n_ for which _n_ × 10_e_-_f_ is larger.
+ 1. Else _fractionDigits_ is *undefined*,
+ 1. Let _e_, _n_, and _f_ be integers such that _f_ ≥ 0, 10_f_ ≤ _n_ < 10_f_+1, the Number value for n × 10_e_-_f_ is _x_, and _f_ is as small as possible. Note that the decimal representation of _n_ has _f_+1 digits, _n_ is not divisible by 10, and the least significant digit of _n_ is not necessarily uniquely determined by these criteria.
+ 1. Let _m_ be the String consisting of the digits of the decimal representation of _n_ (in order, with no leading zeroes).
+ 1. If _f_ ≠ 0, then
+ 1. Let _a_ be the first element of _m_, and let _b_ be the remaining _f_ elements of _m_.
+ 1. Let _m_ be the concatenation of the three Strings _a_, `"."`, and _b_.
+ 1. If _e_ = 0, then
+ 1. Let _c_ be `"+"`.
+ 1. Let _d_ be `"0"`.
+ 1. Else,
+ 1. If _e_ > 0, let _c_ be `"+"`.
+ 1. Else _e_ ≤ 0,
+ 1. Let _c_ be `"-"`.
+ 1. Let _e_ be -_e_.
+ 1. Let _d_ be the String consisting of the digits of the decimal representation of _e_ (in order, with no leading zeroes).
+ 1. Let _m_ be the concatenation of the four Strings _m_, `"e"`, _c_, and _d_.
+ 1. Return the concatenation of the Strings _s_ and _m_.
+
+
If the `toExponential` method is called with more than one argument, then the behaviour is undefined (see clause ).
+
+
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step 11.b.i be used as a guideline:
+
+ 1. Let _e_, _n_, and _f_ be integers such that _f_ ≥ 0, 10_f_ ≤ n < 10_f_+1, the Number value for n × 10_e_-_f_ is x, and _f_ is as small as possible. If there are multiple possibilities for _n_, choose the value of _n_ for which _n_ × 10_e_-_f_ is closest in value to _x_. If there are two such possible values of _n_, choose the one that is even.
+
+
+
+
+
+
+
Number.prototype.toFixed ( _fractionDigits_ )
+
+
`toFixed` returns a String containing this Number value represented in decimal fixed-point notation with _fractionDigits_ digits after the decimal point. If _fractionDigits_ is *undefined*, 0 is assumed.
+
+
The following steps are performed:
+
+ 1. Let _x_ be ? thisNumberValue(*this* value).
+ 1. Let _f_ be ? ToInteger(_fractionDigits_). (If _fractionDigits_ is *undefined*, this step produces the value 0.)
+ 1. If _f_ < 0 or _f_ > 20, throw a *RangeError* exception. However, an implementation is permitted to extend the behaviour of `toFixed` for values of _f_ less than 0 or greater than 20. In this case `toFixed` would not necessarily throw *RangeError* for such values.
+ 1. If _x_ is *NaN*, return the String `"NaN"`.
+ 1. Let _s_ be the empty String.
+ 1. If _x_ < 0, then
+ 1. Let _s_ be `"-"`.
+ 1. Let _x_ be -_x_.
+ 1. If _x_ ≥ 1021, then
+ 1. Let _m_ be ToString(_x_).
+ 1. Else _x_ < 1021,
+ 1. Let _n_ be an integer for which the exact mathematical value of _n_ ÷ 10f - _x_ is as close to zero as possible. If there are two such _n_, pick the larger _n_.
+ 1. If _n_ = 0, let _m_ be the String `"0"`. Otherwise, let _m_ be the String consisting of the digits of the decimal representation of _n_ (in order, with no leading zeroes).
+ 1. If _f_ ≠ 0, then
+ 1. Let _k_ be the number of elements in _m_.
+ 1. If _k_ ≤ _f_, then
+ 1. Let _z_ be the String consisting of _f_+1-_k_ occurrences of the code unit 0x0030.
+ 1. Let _m_ be the concatenation of Strings _z_ and _m_.
+ 1. Let _k_ be _f_ + 1.
+ 1. Let _a_ be the first _k_-_f_ elements of _m_, and let _b_ be the remaining _f_ elements of _m_.
+ 1. Let _m_ be the concatenation of the three Strings _a_, `"."`, and _b_.
+ 1. Return the concatenation of the Strings _s_ and _m_.
+
+
If the `toFixed` method is called with more than one argument, then the behaviour is undefined (see clause ).
+
+
The output of `toFixed` may be more precise than `toString` for some values because toString only prints enough significant digits to distinguish the number from adjacent number values. For example,
+
`(1000000000000000128).toString()` returns `"1000000000000000100"`, while
+
+ `(1000000000000000128).toFixed(0)` returns `"1000000000000000128"`.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `Number.prototype.toLocaleString` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleString` method is used.
+
Produces a String value that represents this Number value formatted according to the conventions of the host environment's current locale. This function is implementation-dependent, and it is permissible, but not encouraged, for it to return the same thing as `toString`.
+
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
The `length` property of the `toLocaleString` method is 0.
+
+
+
+
+
Number.prototype.toPrecision ( _precision_ )
+
Return a String containing this Number value represented either in decimal exponential notation with one digit before the significand's decimal point and _precision_-1 digits after the significand's decimal point or in decimal fixed notation with _precision_ significant digits. If _precision_ is *undefined*, call ToString () instead. Specifically, perform the following steps:
+
+ 1. Let _x_ be ? thisNumberValue(*this* value).
+ 1. If _precision_ is *undefined*, return ToString(_x_).
+ 1. Let _p_ be ? ToInteger(_precision_).
+ 1. If _x_ is *NaN*, return the String `"NaN"`.
+ 1. Let _s_ be the empty String.
+ 1. If _x_ < 0, then
+ 1. Let _s_ be code unit 0x002D (HYPHEN-MINUS).
+ 1. Let _x_ be -_x_.
+ 1. If _x_ = *+∞*, then
+ 1. Return the String that is the concatenation of _s_ and `"Infinity"`.
+ 1. If _p_ < 1 or _p_ > 21, throw a *RangeError* exception. However, an implementation is permitted to extend the behaviour of `toPrecision` for values of _p_ less than 1 or greater than 21. In this case `toPrecision` would not necessarily throw *RangeError* for such values.
+ 1. If _x_ = 0, then
+ 1. Let _m_ be the String consisting of _p_ occurrences of the code unit 0x0030 (DIGIT ZERO).
+ 1. Let _e_ be 0.
+ 1. Else _x_ ≠ 0,
+ 1. Let _e_ and _n_ be integers such that 10_p_-1 ≤ _n_ < 10_p_ and for which the exact mathematical value of _n_ × 10_e_-_p_+1 - _x_ is as close to zero as possible. If there are two such sets of _e_ and _n_, pick the _e_ and _n_ for which _n_ × 10_e_-_p_+1 is larger.
+ 1. Let _m_ be the String consisting of the digits of the decimal representation of _n_ (in order, with no leading zeroes).
+ 1. If _e_ < -6 or _e_ ≥ _p_, then
+ 1. Assert: _e_ ≠ 0.
+ 1. Let _a_ be the first element of _m_, and let _b_ be the remaining _p_-1 elements of _m_.
+ 1. Let _m_ be the concatenation of _a_, `"."`, and _b_.
+ 1. If _e_ > 0, then
+ 1. Let _c_ be code unit 0x002B (PLUS SIGN).
+ 1. Else _e_ < 0,
+ 1. Let _c_ be code unit 0x002D (HYPHEN-MINUS).
+ 1. Let _e_ be -_e_.
+ 1. Let _d_ be the String consisting of the digits of the decimal representation of _e_ (in order, with no leading zeroes).
+ 1. Return the concatenation of _s_, _m_, code unit 0x0065 (LATIN SMALL LETTER E), _c_, and _d_.
+ 1. If _e_ = _p_-1, return the concatenation of the Strings _s_ and _m_.
+ 1. If _e_ ≥ 0, then
+ 1. Let _m_ be the concatenation of the first _e_+1 elements of _m_, the code unit 0x002E (FULL STOP), and the remaining _p_- (_e_+1) elements of _m_.
+ 1. Else _e_ < 0,
+ 1. Let _m_ be the String formed by the concatenation of code unit 0x0030 (DIGIT ZERO), code unit 0x002E (FULL STOP), -(_e_+1) occurrences of code unit 0x0030 (DIGIT ZERO), and the String _m_.
+ 1. Return the String that is the concatenation of _s_ and _m_.
+
+
If the `toPrecision` method is called with more than one argument, then the behaviour is undefined (see clause ).
+
+
+
+
+
Number.prototype.toString ( [ _radix_ ] )
+
+
The optional _radix_ should be an integer value in the inclusive range 2 to 36. If _radix_ not present or is *undefined* the Number 10 is used as the value of _radix_.
+
+
The following steps are performed:
+
+ 1. Let _x_ be ? thisNumberValue(*this* value).
+ 1. If _radix_ is not present, let _radixNumber_ be 10.
+ 1. Else if _radix_ is *undefined*, let _radixNumber_ be 10.
+ 1. Else let _radixNumber_ be ? ToInteger(_radix_).
+ 1. If _radixNumber_ < 2 or _radixNumber_ > 36, throw a *RangeError* exception.
+ 1. If _radixNumber_ = 10, return ToString(_x_).
+ 1. Return the String representation of this Number value using the radix specified by _radixNumber_. Letters `a`-`z` are used for digits with values 10 through 35. The precise algorithm is implementation-dependent, however the algorithm should be a generalization of that specified in .
+
+
The `toString` function is not generic; it throws a *TypeError* exception if its *this* value is not a Number or a Number object. Therefore, it cannot be transferred to other kinds of objects for use as a method.
+
+
+
+
+
Number.prototype.valueOf ( )
+
+ 1. Let _x_ be thisNumberValue(*this* value).
+ 1. Return _x_.
+
+
+
+
+
+
+
Properties of Number Instances
+
Number instances are ordinary objects that inherit properties from the Number prototype object. Number instances also have a [[NumberData]] internal slot. The [[NumberData]] internal slot is the Number value represented by this Number object.
+
+
+
+
+
+
The Math Object
+
The Math object is the %Math% intrinsic object and the initial value of the `Math` property of the global object. The Math object is a single ordinary object.
+
The value of the [[Prototype]] internal slot of the Math object is the intrinsic object %ObjectPrototype% ().
+
The Math object is not a function object. It does not have a [[Construct]] internal method; it is not possible to use the Math object as a constructor with the `new` operator. The Math object also does not have a [[Call]] internal method; it is not possible to invoke the Math object as a function.
+
+
In this specification, the phrase “the Number value for _x_” has a technical meaning defined in .
+
+
+
+
+
Value Properties of the Math Object
+
+
+
+
Math.E
+
The Number value for _e_, the base of the natural logarithms, which is approximately 2.7182818284590452354.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Math.LN10
+
The Number value for the natural logarithm of 10, which is approximately 2.302585092994046.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Math.LN2
+
The Number value for the natural logarithm of 2, which is approximately 0.6931471805599453.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Math.LOG10E
+
The Number value for the base-10 logarithm of _e_, the base of the natural logarithms; this value is approximately 0.4342944819032518.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
The value of `Math.LOG10E` is approximately the reciprocal of the value of `Math.LN10`.
+
+
+
+
+
+
Math.LOG2E
+
The Number value for the base-2 logarithm of _e_, the base of the natural logarithms; this value is approximately 1.4426950408889634.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
The value of `Math.LOG2E` is approximately the reciprocal of the value of `Math.LN2`.
+
+
+
+
+
+
Math.PI
+
The Number value for π, the ratio of the circumference of a circle to its diameter, which is approximately 3.1415926535897932.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Math.SQRT1_2
+
The Number value for the square root of ½, which is approximately 0.7071067811865476.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
The value of `Math.SQRT1_2` is approximately the reciprocal of the value of `Math.SQRT2`.
+
+
+
+
+
+
Math.SQRT2
+
The Number value for the square root of 2, which is approximately 1.4142135623730951.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Math [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Math"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Function Properties of the Math Object
+
Each of the following `Math` object functions applies the ToNumber abstract operation to each of its arguments (in left-to-right order if there is more than one). If ToNumber returns an abrupt completion, that Completion Record is immediately returned. Otherwise, the function performs a computation on the resulting Number value(s). The value returned by each function is a Number.
+
In the function descriptions below, the symbols NaN, -0, +0, *-∞* and *+∞* refer to the Number values described in .
+
+
The behaviour of the functions `acos`, `acosh`, `asin`, `asinh`, `atan`, `atanh`, `atan2`, `cbrt`, `cos`, `cosh`, `exp`, `expm1`, `hypot`, `log`,`log1p`, `log2`, `log10`, `pow`, `random`, `sin`, `sinh`, `sqrt`, `tan`, and `tanh` is not precisely specified here except to require specific results for certain argument values that represent boundary cases of interest. For other argument values, these functions are intended to compute approximations to the results of familiar mathematical functions, but some latitude is allowed in the choice of approximation algorithms. The general intent is that an implementer should be able to use the same mathematical library for ECMAScript on a given hardware platform that is available to C programmers on that platform.
+
Although the choice of algorithms is left to the implementation, it is recommended (but not specified by this standard) that implementations use the approximation algorithms for IEEE 754-2008 arithmetic contained in `fdlibm`, the freely distributable mathematical library from Sun Microsystems (http://www.netlib.org/fdlibm).
+
+
+
+
+
Math.abs ( _x_ )
+
Returns the absolute value of _x_; the result has the same magnitude as _x_ but has positive sign.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is -0, the result is +0.
+
+
+ If _x_ is *-∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.acos ( _x_ )
+
Returns an implementation-dependent approximation to the arc cosine of _x_. The result is expressed in radians and ranges from *+0* to +π.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is greater than 1, the result is NaN.
+
+
+ If _x_ is less than -1, the result is NaN.
+
+
+ If _x_ is exactly 1, the result is +0.
+
+
+
+
+
+
+
Math.acosh( _x_ )
+
Returns an implementation-dependent approximation to the inverse hyperbolic cosine of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If x is less than 1, the result is NaN.
+
+
+ If x is 1, the result is +0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.asin ( _x_ )
+
Returns an implementation-dependent approximation to the arc sine of _x_. The result is expressed in radians and ranges from -π/2 to +π/2.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is greater than 1, the result is NaN.
+
+
+ If _x_ is less than -1, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+
+
+
+
+
Math.asinh( _x_ )
+
Returns an implementation-dependent approximation to the inverse hyperbolic sine of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If x is *-∞*, the result is *-∞*.
+
+
+
+
+
+
+
Math.atan ( _x_ )
+
Returns an implementation-dependent approximation to the arc tangent of _x_. The result is expressed in radians and ranges from -π/2 to +π/2.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is an implementation-dependent approximation to +π/2.
+
+
+ If _x_ is *-∞*, the result is an implementation-dependent approximation to -π/2.
+
+
+
+
+
+
+
Math.atanh( _x_ )
+
Returns an implementation-dependent approximation to the inverse hyperbolic tangent of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is less than -1, the result is NaN.
+
+
+ If _x_ is greater than 1, the result is NaN.
+
+
+ If _x_ is -1, the result is *-∞*.
+
+
+ If _x_ is +1, the result is *+∞*.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+
+
+
+
+
Math.atan2 ( _y_, _x_ )
+
Returns an implementation-dependent approximation to the arc tangent of the quotient _y_/_x_ of the arguments _y_ and _x_, where the signs of _y_ and _x_ are used to determine the quadrant of the result. Note that it is intentional and traditional for the two-argument arc tangent function that the argument named _y_ be first and the argument named _x_ be second. The result is expressed in radians and ranges from -π to +π.
+
+
+ If either _x_ or _y_ is NaN, the result is NaN.
+
+
+ If _y_>0 and _x_ is +0, the result is an implementation-dependent approximation to +π/2.
+
+
+ If _y_>0 and _x_ is -0, the result is an implementation-dependent approximation to +π/2.
+
+
+ If _y_ is +0 and _x_>0, the result is +0.
+
+
+ If _y_ is +0 and _x_ is +0, the result is +0.
+
+
+ If _y_ is +0 and _x_ is -0, the result is an implementation-dependent approximation to +π.
+
+
+ If _y_ is +0 and _x_<0, the result is an implementation-dependent approximation to +π.
+
+
+ If _y_ is -0 and _x_>0, the result is -0.
+
+
+ If _y_ is -0 and _x_ is +0, the result is -0.
+
+
+ If _y_ is -0 and _x_ is -0, the result is an implementation-dependent approximation to -π.
+
+
+ If _y_ is -0 and _x_<0, the result is an implementation-dependent approximation to -π.
+
+
+ If _y_<0 and _x_ is +0, the result is an implementation-dependent approximation to -π/2.
+
+
+ If _y_<0 and _x_ is -0, the result is an implementation-dependent approximation to -π/2.
+
+
+ If _y_>0 and _y_ is finite and _x_ is *+∞*, the result is +0.
+
+
+ If _y_>0 and _y_ is finite and _x_ is *-∞*, the result is an implementation-dependent approximation to +π.
+
+
+ If _y_<0 and _y_ is finite and _x_ is *+∞*, the result is -0.
+
+
+ If _y_<0 and _y_ is finite and _x_ is *-∞*, the result is an implementation-dependent approximation to -π.
+
+
+ If _y_ is *+∞* and _x_ is finite, the result is an implementation-dependent approximation to +π/2.
+
+
+ If _y_ is *-∞* and _x_ is finite, the result is an implementation-dependent approximation to -π/2.
+
+
+ If _y_ is *+∞* and _x_ is *+∞*, the result is an implementation-dependent approximation to +π/4.
+
+
+ If _y_ is *+∞* and _x_ is *-∞*, the result is an implementation-dependent approximation to +3π/4.
+
+
+ If _y_ is *-∞* and _x_ is *+∞*, the result is an implementation-dependent approximation to -π/4.
+
+
+ If _y_ is *-∞* and _x_ is *-∞*, the result is an implementation-dependent approximation to -3π/4.
+
+
+
+
+
+
+
Math.cbrt ( _x_ )
+
Returns an implementation-dependent approximation to the cube root of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is *-∞*.
+
+
+
+
+
+
+
Math.ceil ( _x_ )
+
Returns the smallest (closest to *-∞*) Number value that is not less than _x_ and is equal to a mathematical integer. If _x_ is already an integer, the result is _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is *-∞*.
+
+
+ If _x_ is less than 0 but greater than -1, the result is -0.
+
+
+
The value of `Math.ceil(x)` is the same as the value of `-Math.floor(-x)`.
+
+
+
+
+
Math.clz32 ( _x_ )
+
When `Math.clz32` is called with one argument _x_, the following steps are taken:
+
+ 1. Let _n_ be ToUint32(_x_).
+ 1. Let _p_ be the number of leading zero bits in the 32-bit binary representation of _n_.
+ 1. Return _p_.
+
+
+
If _n_ is 0, _p_ will be 32. If the most significant bit of the 32-bit binary encoding of _n_ is 1, _p_ will be 0.
+
+
+
+
+
+
Math.cos ( _x_ )
+
Returns an implementation-dependent approximation to the cosine of _x_. The argument is expressed in radians.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is 1.
+
+
+ If _x_ is -0, the result is 1.
+
+
+ If _x_ is *+∞*, the result is NaN.
+
+
+ If _x_ is *-∞*, the result is NaN.
+
+
+
+
+
+
+
Math.cosh ( _x_ )
+
Returns an implementation-dependent approximation to the hyperbolic cosine of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is 1.
+
+
+ If _x_ is -0, the result is 1.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is *+∞*.
+
+
+
+
The value of cosh(x) is the same as (exp(x) + exp(-x))/2.
+
+
+
+
+
+
Math.exp ( _x_ )
+
Returns an implementation-dependent approximation to the exponential function of _x_ (_e_ raised to the power of _x_, where _e_ is the base of the natural logarithms).
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is 1.
+
+
+ If _x_ is -0, the result is 1.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is +0.
+
+
+
+
+
+
+
Math.expm1 ( _x_ )
+
Returns an implementation-dependent approximation to subtracting 1 from the exponential function of _x_ (_e_ raised to the power of _x_, where _e_ is the base of the natural logarithms). The result is computed in a way that is accurate even when the value of x is close 0.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is -1.
+
+
+
+
+
+
+
Math.floor ( _x_ )
+
Returns the greatest (closest to *+∞*) Number value that is not greater than _x_ and is equal to a mathematical integer. If _x_ is already an integer, the result is _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is *-∞*.
+
+
+ If _x_ is greater than 0 but less than 1, the result is +0.
+
+
+
+
The value of `Math.floor(x)` is the same as the value of `-Math.ceil(-x)`.
+
+
+
+
+
+
Math.fround ( _x_ )
+
When `Math.fround` is called with argument _x_ the following steps are taken:
+
+ 1. If _x_ is NaN, return NaN.
+ 1. If _x_ is one of +0, -0, *+∞*, *-∞*, return _x_.
+ 1. Let _x32_ be the result of converting _x_ to a value in IEEE 754-2008 binary32 format using roundTiesToEven.
+ 1. Let _x64_ be the result of converting _x32_ to a value in IEEE 754-2008 binary64 format.
+ 1. Return the ECMAScript Number value corresponding to _x64_.
+
+
+
+
+
+
Math.hypot ( _value1_ , _value2_ , …_values_ )
+
`Math.hypot` returns an implementation-dependent approximation of the square root of the sum of squares of its arguments.
+
+
+ If no arguments are passed, the result is +0.
+
+
+ If any argument is *+∞*, the result is *+∞*.
+
+
+ If any argument is *-∞*, the result is *+∞*.
+
+
+ If no argument is *+∞* or *-∞*, and any argument is NaN, the result is NaN.
+
+
+ If all arguments are either +0 or -0, the result is +0.
+
+
+
The length property of the `hypot` function is 2.
+
+
Implementations should take care to avoid the loss of precision from overflows and underflows that are prone to occur in naive implementations when this function is called with two or more arguments.
+
+
+
+
+
+
Math.imul ( _x_, _y_ )
+
When the `Math.imul` is called with arguments _x_ and _y_ the following steps are taken:
+
+ 1. Let _a_ be ToUint32(_x_).
+ 1. Let _b_ be ToUint32(_y_).
+ 1. Let _product_ be (_a_ × _b_) modulo 232.
+ 1. If _product_ ≥ 231, return _product_ - 232; otherwise return _product_.
+
+
+
+
+
+
Math.log ( _x_ )
+
Returns an implementation-dependent approximation to the natural logarithm of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is less than 0, the result is NaN.
+
+
+ If _x_ is +0 or -0, the result is *-∞*.
+
+
+ If _x_ is 1, the result is +0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.log1p ( _x_ )
+
Returns an implementation-dependent approximation to the natural logarithm of 1 + _x_. The result is computed in a way that is accurate even when the value of x is close to zero.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is less than -1, the result is NaN.
+
+
+ If x is -1, the result is *-∞*.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.log10 ( _x_ )
+
Returns an implementation-dependent approximation to the base 10 logarithm of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is less than 0, the result is NaN.
+
+
+ If _x_ is +0, the result is *-∞*.
+
+
+ If _x_ is -0, the result is *-∞*.
+
+
+ If _x_ is 1, the result is +0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.log2 ( _x_ )
+
Returns an implementation-dependent approximation to the base 2 logarithm of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is less than 0, the result is NaN.
+
+
+ If _x_ is +0, the result is *-∞*.
+
+
+ If _x_ is -0, the result is *-∞*.
+
+
+ If _x_ is 1, the result is +0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.max ( _value1_, _value2_ , …_values_ )
+
Given zero or more arguments, calls ToNumber on each of the arguments and returns the largest of the resulting values.
+
+
+ If no arguments are given, the result is *-∞*.
+
+
+ If any value is NaN, the result is NaN.
+
+
+ The comparison of values to determine the largest value is done using the Abstract Relational Comparison algorithm () except that +0 is considered to be larger than -0.
+
+
+
The `length` property of the `max` method is 2.
+
+
+
+
+
Math.min ( _value1_, _value2_ , …_values_ )
+
Given zero or more arguments, calls ToNumber on each of the arguments and returns the smallest of the resulting values.
+
+
+ If no arguments are given, the result is *+∞*.
+
+
+ If any value is NaN, the result is NaN.
+
+
+ The comparison of values to determine the smallest value is done using the Abstract Relational Comparison algorithm () except that +0 is considered to be larger than -0.
+
+
+
The `length` property of the `min` method is 2.
+
+
+
+
+
Math.pow ( _x_, _y_ )
+
Returns an implementation-dependent approximation to the result of raising _x_ to the power _y_.
+
+
+ If _y_ is NaN, the result is NaN.
+
+
+ If _y_ is +0, the result is 1, even if _x_ is NaN.
+
+
+ If _y_ is -0, the result is 1, even if _x_ is NaN.
+
+
+ If _x_ is NaN and _y_ is nonzero, the result is NaN.
+
+
+ If abs(_x_)>1 and _y_ is *+∞*, the result is *+∞*.
+
+
+ If abs(_x_)>1 and _y_ is *-∞*, the result is +0.
+
+
+ If abs(_x_) is 1 and _y_ is *+∞*, the result is NaN.
+
+
+ If abs(_x_) is 1 and _y_ is *-∞*, the result is NaN.
+
+
+ If abs(_x_)<1 and _y_ is *+∞*, the result is +0.
+
+
+ If abs(_x_)<1 and _y_ is *-∞*, the result is *+∞*.
+
+
+ If _x_ is *+∞* and _y_>0, the result is *+∞*.
+
+
+ If _x_ is *+∞* and _y_<0, the result is +0.
+
+
+ If _x_ is *-∞* and _y_>0 and _y_ is an odd integer, the result is *-∞*.
+
+
+ If _x_ is *-∞* and _y_>0 and _y_ is not an odd integer, the result is *+∞*.
+
+
+ If _x_ is *-∞* and _y_<0 and _y_ is an odd integer, the result is -0.
+
+
+ If _x_ is *-∞* and _y_<0 and _y_ is not an odd integer, the result is +0.
+
+
+ If _x_ is +0 and _y_>0, the result is +0.
+
+
+ If _x_ is +0 and _y_<0, the result is *+∞*.
+
+
+ If _x_ is -0 and _y_>0 and _y_ is an odd integer, the result is -0.
+
+
+ If _x_ is -0 and _y_>0 and _y_ is not an odd integer, the result is +0.
+
+
+ If _x_ is -0 and _y_<0 and _y_ is an odd integer, the result is *-∞*.
+
+
+ If _x_ is -0 and _y_<0 and _y_ is not an odd integer, the result is *+∞*.
+
+
+ If _x_<0 and _x_ is finite and _y_ is finite and _y_ is not an integer, the result is NaN.
+
+
+
+
+
The result of `Math.pow(x, y)` when _x_ is *1* or *-1* and _y_ is *+Infinity* or *-Infinity* differs from IEEE 754-2008. The first edition of ECMAScript specified a result of *NaN* for this operation, whereas later versions of IEEE 754-2008 specified *1*. The historical ECMAScript behaviour is preserved for compatibility reasons.
+
+
+
+
+
+
Math.random ( )
+
Returns a Number value with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-dependent algorithm or strategy. This function takes no arguments.
+
Each `Math.random` function created for distinct code Realms must produce a distinct sequence of values from successive calls.
+
+
+
+
+
Math.round ( _x_ )
+
Returns the Number value that is closest to _x_ and is equal to a mathematical integer. If two integer Number values are equally close to _x_, then the result is the Number value that is closer to *+∞*. If _x_ is already an integer, the result is _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If _x_ is *-∞*, the result is *-∞*.
+
+
+ If _x_ is greater than 0 but less than 0.5, the result is +0.
+
+
+ If _x_ is less than 0 but greater than or equal to -0.5, the result is -0.
+
+
+
+
`Math.round(3.5)` returns 4, but `Math.round(-3.5)` returns -3.
+
+
+
The value of `Math.round(x)` is not always the same as the value of `Math.floor(x+0.5)`. When `x` is *-0* or is less than 0 but greater than or equal to -0.5, `Math.round(x)` returns *-0*, but `Math.floor(x+0.5)` returns *+0*. `Math.round(x)` may also differ from the value of `Math.floor(x+0.5)`because of internal rounding when computing `x+0.5`.
+
+
+
+
+
+
Math.sign(_x_)
+
Returns the sign of the x, indicating whether x is positive, negative or zero.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is negative and not -0, the result is -1.
+
+
+ If _x_ is positive and not +0, the result is +1.
+
+
+
+
+
+
+
Math.sin ( _x_ )
+
Returns an implementation-dependent approximation to the sine of _x_. The argument is expressed in radians.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞* or *-∞*, the result is NaN.
+
+
+
+
+
+
+
Math.sinh( _x_ )
+
Returns an implementation-dependent approximation to the hyperbolic sine of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If x is *-∞*, the result is *-∞*.
+
+
+
+
The value of sinh(x) is the same as (exp(x) - exp(-x))/2.
+
+
+
+
+
+
Math.sqrt ( _x_ )
+
Returns an implementation-dependent approximation to the square root of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is less than 0, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+
+
+
+
+
Math.tan ( _x_ )
+
Returns an implementation-dependent approximation to the tangent of _x_. The argument is expressed in radians.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞* or *-∞*, the result is NaN.
+
+
+
+
+
+
+
Math.tanh ( _x_ )
+
Returns an implementation-dependent approximation to the hyperbolic tangent of _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is *+∞*, the result is +1.
+
+
+ If _x_ is *-∞*, the result is -1.
+
+
+
+
The value of tanh(x) is the same as (exp(x) - exp(-x))/(exp(x) + exp(-x)).
+
+
+
+
+
+
Math.trunc ( _x_ )
+
Returns the integral part of the number _x_, removing any fractional digits. If _x_ is already an integer, the result is _x_.
+
+
+ If _x_ is NaN, the result is NaN.
+
+
+ If _x_ is -0, the result is -0.
+
+
+ If _x_ is +0, the result is +0.
+
+
+ If _x_ is *+∞*, the result is *+∞*.
+
+
+ If x is *-∞*, the result is *-∞*.
+
+
+ If _x_ is greater than 0 but less than 1, the result is +0.
+
+
+ If _x_ is less than 0 but greater than -1, the result is -0.
+
+
+
+
+
+
+
+
+
Date Objects
+
+
+
+
Overview of Date Objects and Definitions of Abstract Operations
+
The following functions are abstract operations that operate on time values (defined in ). Note that, in every case, if any argument to one of these functions is *NaN*, the result will be *NaN*.
+
+
+
+
Time Values and Time Range
+
A Date object contains a Number indicating a particular instant in time to within a millisecond. Such a Number is called a time value. A time value may also be *NaN*, indicating that the Date object does not represent a specific instant of time.
+
Time is measured in ECMAScript in milliseconds since 01 January, 1970 UTC. In time values leap seconds are ignored. It is assumed that there are exactly 86,400,000 milliseconds per day. ECMAScript Number values can represent all integers from -9,007,199,254,740,992 to 9,007,199,254,740,992; this range suffices to measure times to millisecond precision for any instant that is within approximately 285,616 years, either forward or backward, from 01 January, 1970 UTC.
+
The actual range of times supported by ECMAScript Date objects is slightly smaller: exactly -100,000,000 days to 100,000,000 days measured relative to midnight at the beginning of 01 January, 1970 UTC. This gives a range of 8,640,000,000,000,000 milliseconds to either side of 01 January, 1970 UTC.
+
The exact moment of midnight at the beginning of 01 January, 1970 UTC is represented by the value *+0*.
ECMAScript uses an extrapolated Gregorian system to map a day number to a year number and to determine the month and date within that year. In this system, leap years are precisely those which are (divisible by 4) and ((not divisible by 100) or (divisible by 400)). The number of days in year number _y_ is therefore defined by
+ DaysInYear(_y_)
+ = 365 if (_y_ modulo 4) ≠ 0
+ = 366 if (_y_ modulo 4) = 0 and (_y_ modulo 100) ≠ 0
+ = 365 if (_y_ modulo 100) = 0 and (_y_ modulo 400) ≠ 0
+ = 366 if (_y_ modulo 400) = 0
+
+
All non-leap years have 365 days with the usual number of days per month and leap years have an extra day in February. The day number of the first day of year _y_ is given by:
Months are identified by an integer in the range 0 to 11, inclusive. The mapping MonthFromTime(_t_) from a time value _t_ to a month number is defined by:
+ MonthFromTime(_t_)
+ = 0 if 0 ≤ DayWithinYear(_t_) < 31
+ = 1 if 31 ≤ DayWithinYear(_t_) < 59+InLeapYear(_t_)
+ = 2 if 59+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 90+InLeapYear(_t_)
+ = 3 if 90+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 120+InLeapYear(_t_)
+ = 4 if 120+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 151+InLeapYear(_t_)
+ = 5 if 151+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 181+InLeapYear(_t_)
+ = 6 if 181+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 212+InLeapYear(_t_)
+ = 7 if 212+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 243+InLeapYear(_t_)
+ = 8 if 243+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 273+InLeapYear(_t_)
+ = 9 if 273+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 304+InLeapYear(_t_)
+ = 10 if 304+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 334+InLeapYear(_t_)
+ = 11 if 334+InLeapYear(_t_) ≤ DayWithinYear(_t_) < 365+InLeapYear(_t_)
+
+
A month value of 0 specifies January; 1 specifies February; 2 specifies March; 3 specifies April; 4 specifies May; 5 specifies June; 6 specifies July; 7 specifies August; 8 specifies September; 9 specifies October; 10 specifies November; and 11 specifies December. Note that MonthFromTime(0) = 0, corresponding to Thursday, 01 January, 1970.
+
+
+
+
+
Date Number
+
A date number is identified by an integer in the range 1 through 31, inclusive. The mapping DateFromTime(_t_) from a time value _t_ to a date number is defined by:
+ DateFromTime(_t_)
+ = DayWithinYear(_t_)+1 if MonthFromTime(_t_)=0
+ = DayWithinYear(_t_)-30 if MonthFromTime(_t_)=1
+ = DayWithinYear(_t_)-58-InLeapYear(_t_) if MonthFromTime(_t_)=2
+ = DayWithinYear(_t_)-89-InLeapYear(_t_) if MonthFromTime(_t_)=3
+ = DayWithinYear(_t_)-119-InLeapYear(_t_) if MonthFromTime(_t_)=4
+ = DayWithinYear(_t_)-150-InLeapYear(_t_) if MonthFromTime(_t_)=5
+ = DayWithinYear(_t_)-180-InLeapYear(_t_) if MonthFromTime(_t_)=6
+ = DayWithinYear(_t_)-211-InLeapYear(_t_) if MonthFromTime(_t_)=7
+ = DayWithinYear(_t_)-242-InLeapYear(_t_) if MonthFromTime(_t_)=8
+ = DayWithinYear(_t_)-272-InLeapYear(_t_) if MonthFromTime(_t_)=9
+ = DayWithinYear(_t_)-303-InLeapYear(_t_) if MonthFromTime(_t_)=10
+ = DayWithinYear(_t_)-333-InLeapYear(_t_) if MonthFromTime(_t_)=11
+
+
+
+
+
+
Week Day
+
The weekday for a particular time value _t_ is defined as
+ WeekDay(_t_) = (Day(_t_) + 4) modulo 7
+
A weekday value of 0 specifies Sunday; 1 specifies Monday; 2 specifies Tuesday; 3 specifies Wednesday; 4 specifies Thursday; 5 specifies Friday; and 6 specifies Saturday. Note that WeekDay(0) = 4, corresponding to Thursday, 01 January, 1970.
+
+
+
+
+
Local Time Zone Adjustment
+
An implementation of ECMAScript is expected to determine the local time zone adjustment. The local time zone adjustment is a value LocalTZA measured in milliseconds which when added to UTC represents the local standard time. Daylight saving time is not reflected by LocalTZA.
+
+
It is recommended that implementations use the time zone information of the IANA Time Zone Database http://www.iana.org/time-zones/.
+
+
+
+
+
+
Daylight Saving Time Adjustment
+
An implementation dependent algorithm using best available information on time zones to determine the local daylight saving time adjustment DaylightSavingTA(_t_), measured in milliseconds. An implementation of ECMAScript is expected to make its best effort to determine the local daylight saving time adjustment.
+
+
It is recommended that implementations use the time zone information of the IANA Time Zone Database http://www.iana.org/time-zones/.
+
+
+
+
+
+
LocalTime ( _t_ )
+
The abstract operation LocalTime with argument _t_ converts _t_ from UTC to local time by performing the following steps:
The abstract operation MakeTime calculates a number of milliseconds from its four arguments, which must be ECMAScript Number values. This operator functions as follows:
+
+ 1. If _hour_ is not finite or _min_ is not finite or _sec_ is not finite or _ms_ is not finite, return *NaN*.
+ 1. Let _h_ be ToInteger(_hour_).
+ 1. Let _m_ be ToInteger(_min_).
+ 1. Let _s_ be ToInteger(_sec_).
+ 1. Let _milli_ be ToInteger(_ms_).
+ 1. Let _t_ be _h_ `*` msPerHour `+` _m_ `*` msPerMinute `+` _s_ `*` msPerSecond `+` _milli_, performing the arithmetic according to IEEE 754-2008 rules (that is, as if using the ECMAScript operators `*` and `+`).
+ 1. Return _t_.
+
+
+
+
+
+
MakeDay (_year_, _month_, _date_)
+
The abstract operation MakeDay calculates a number of days from its three arguments, which must be ECMAScript Number values. This operator functions as follows:
+
+ 1. If _year_ is not finite or _month_ is not finite or _date_ is not finite, return *NaN*.
+ 1. Let _y_ be ToInteger(_year_).
+ 1. Let _m_ be ToInteger(_month_).
+ 1. Let _dt_ be ToInteger(_date_).
+ 1. Let _ym_ be _y_ + floor(_m_ /12).
+ 1. Let _mn_ be _m_ modulo 12.
+ 1. Find a value _t_ such that YearFromTime(_t_) is _ym_ and MonthFromTime(_t_) is _mn_ and DateFromTime(_t_) is 1; but if this is not possible (because some argument is out of range), return *NaN*.
+ 1. Return Day(_t_) + _dt_ - 1.
+
+
+
+
+
+
MakeDate (_day_, _time_)
+
The abstract operation MakeDate calculates a number of milliseconds from its two arguments, which must be ECMAScript Number values. This operator functions as follows:
+
+ 1. If _day_ is not finite or _time_ is not finite, return *NaN*.
+ 1. Return _day_ × msPerDay + _time_.
+
+
+
+
+
+
TimeClip (_time_)
+
The abstract operation TimeClip calculates a number of milliseconds from its argument, which must be an ECMAScript Number value. This operator functions as follows:
+
+ 1. If _time_ is not finite, return *NaN*.
+ 1. If abs(_time_) > 8.64 × 1015, return *NaN*.
+ 1. Return ToInteger(_time_) + (*+0*). (Adding a positive zero converts *-0* to *+0*.)
+
+
+
The point of step 3 is that an implementation is permitted a choice of internal representations of time values, for example as a 64-bit signed integer or as a 64-bit floating-point value. Depending on the implementation, this internal representation may or may not distinguish *-0* and *+0*.
+
+
+
+
+
+
Date Time String Format
+
ECMAScript defines a string interchange format for date-times based upon a simplification of the ISO 8601 Extended Format. The format is as follows: `YYYY-MM-DDTHH:mm:ss.sssZ`
+
Where the fields are as follows:
+
+
+
+
+
+ `YYYY`
+
+
+ is the decimal digits of the year 0000 to 9999 in the Gregorian calendar.
+
+
+
+
+ `-`
+
+
+ `"-"` (hyphen) appears literally twice in the string.
+
+
+
+
+ `MM`
+
+
+ is the month of the year from 01 (January) to 12 (December).
+
+
+
+
+ `DD`
+
+
+ is the day of the month from 01 to 31.
+
+
+
+
+ `T`
+
+
+ `"T"` appears literally in the string, to indicate the beginning of the time element.
+
+
+
+
+ `HH`
+
+
+ is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24.
+
+
+
+
+ `:`
+
+
+ `":"` (colon) appears literally twice in the string.
+
+
+
+
+ `mm`
+
+
+ is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59.
+
+
+
+
+ `ss`
+
+
+ is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59.
+
+
+
+
+ `.`
+
+
+ `"."` (dot) appears literally in the string.
+
+
+
+
+ `sss`
+
+
+ is the number of complete milliseconds since the start of the second as three decimal digits.
+
+
+
+
+ `Z`
+
+
+ is the time zone offset specified as `"Z"` (for UTC) or either `"+"` or `"-"` followed by a time expression `HH:mm`
+
+
+
+
+
+
This format includes date-only forms:
+
+YYYY
+YYYY-MM
+YYYY-MM-DD
+
+
It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional time zone offset appended:
+
+THH:mm
+THH:mm:ss
+THH:mm:ss.sss
+
+
All numbers must be base 10. If the `MM` or `DD` fields are absent `"01"` is used as the value. If the `HH`, `mm`, or `ss` fields are absent `"00"` is used as the value and the value of an absent `sss` field is `"000"`. When the time zone offset is absent, date-only forms are interpreted as a UTC time and date-time forms are interpreted as a local time.
+
Illegal values (out-of-bounds as well as syntax errors) in a format string means that the format string is not a valid instance of this format.
+
+
As every day both starts and ends with midnight, the two notations `00:00` and `24:00` are available to distinguish the two midnights that can be associated with one date. This means that the following two notations refer to exactly the same point in time: `1995-02-04T24:00` and `1995-02-05T00:00`
+
+
+
There exists no international standard that specifies abbreviations for civil time zones like CET, EST, etc. and sometimes the same abbreviation is even used for two very different time zones. For this reason, ISO 8601 and this format specifies numeric representations of date and time.
+
+
+
+
+
Extended years
+
ECMAScript requires the ability to specify 6 digit years (extended years); approximately 285,426 years, either forward or backward, from 01 January, 1970 UTC. To represent years before 0 or after 9999, ISO 8601 permits the expansion of the year representation, but only by prior agreement between the sender and the receiver. In the simplified ECMAScript format such an expanded year representation shall have 2 extra year digits and is always prefixed with a + or - sign. The year 0 is considered positive and hence prefixed with a + sign.
+
+
Examples of extended years:
+
+
+
+
+
+
-283457-03-21T15:00:59.008Z
+
+
+
283458 B.C.
+
+
+
+
+
-000001-01-01T00:00:00Z
+
+
+
2 B.C.
+
+
+
+
+
+000000-01-01T00:00:00Z
+
+
+
1 B.C.
+
+
+
+
+
+000001-01-01T00:00:00Z
+
+
+
1 A.D.
+
+
+
+
+
+001970-01-01T00:00:00Z
+
+
+
1970 A.D.
+
+
+
+
+
+002009-12-15T00:00:00Z
+
+
+
2009 A.D.
+
+
+
+
+
+287396-10-12T08:59:00.992Z
+
+
+
287396 A.D.
+
+
+
+
+
+
+
+
+
+
+
+
+
The Date Constructor
+
The Date constructor is the %Date% intrinsic object and the initial value of the `Date` property of the global object. When called as a constructor it creates and initializes a new Date object. When `Date` is called as a function rather than as a constructor, it returns a String representing the current time (UTC).
+
The `Date` constructor is a single function whose behaviour is overloaded based upon the number and types of its arguments.
+
The `Date` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Date` behaviour must include a `super` call to the `Date` constructor to create and initialize the subclass instance with a [[DateValue]] internal slot.
This description applies only if the Date constructor is called with at least two arguments.
+
When the `Date` function is called the following steps are taken:
+
+ 1. Let _numberOfArgs_ be the number of arguments passed to this function call.
+ 1. Assert: _numberOfArgs_ ≥ 2.
+ 1. If NewTarget is not *undefined*, then
+ 1. Let _y_ be ? ToNumber(_year_).
+ 1. Let _m_ be ? ToNumber(_month_).
+ 1. If _date_ is supplied, let _dt_ be ? ToNumber(_date_); else let _dt_ be 1.
+ 1. If _hours_ is supplied, let _h_ be ? ToNumber(_hours_); else let _h_ be 0.
+ 1. If _minutes_ is supplied, let _min_ be ? ToNumber(_minutes_); else let _min_ be 0.
+ 1. If _seconds_ is supplied, let _s_ be ? ToNumber(_seconds_); else let _s_ be 0.
+ 1. If _ms_ is supplied, let _milli_ be ? ToNumber(_ms_); else let _milli_ be 0.
+ 1. If _y_ is not *NaN* and 0 ≤ ToInteger(_y_) ≤ 99, let _yr_ be 1900+ToInteger(_y_); otherwise, let _yr_ be _y_.
+ 1. Let _finalDate_ be MakeDate(MakeDay(_yr_, _m_, _dt_), MakeTime(_h_, _min_, _s_, _milli_)).
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%DatePrototype%"`, « [[DateValue]] »).
+ 1. Set the [[DateValue]] internal slot of _O_ to TimeClip(UTC(_finalDate_)).
+ 1. Return _O_.
+ 1. Else,
+ 1. Let _now_ be the Number that is the time value (UTC) identifying the current time.
+ 1. Return ToDateString(_now_).
+
+
+
+
+
+
Date ( _value_ )
+
This description applies only if the Date constructor is called with exactly one argument.
+
When the `Date` function is called the following steps are taken:
+
+ 1. Let _numberOfArgs_ be the number of arguments passed to this function call.
+ 1. Assert: _numberOfArgs_ = 1.
+ 1. If NewTarget is not *undefined*, then
+ 1. If Type(_value_) is Object and _value_ has a [[DateValue]] internal slot, then
+ 1. Let _tv_ be thisTimeValue(_value_).
+ 1. Else,
+ 1. Let _v_ be ToPrimitive(_value_).
+ 1. If Type(_v_) is String, then
+ 1. Let _tv_ be the result of parsing _v_ as a date, in exactly the same manner as for the `parse` method (). If the parse resulted in an abrupt completion, _tv_ is the Completion Record.
+ 1. Else,
+ 1. Let _tv_ be ToNumber(_v_).
+ 1. ReturnIfAbrupt(_tv_).
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%DatePrototype%"`, « [[DateValue]] »).
+ 1. Set the [[DateValue]] internal slot of _O_ to TimeClip(_tv_).
+ 1. Return _O_.
+ 1. Else,
+ 1. Let _now_ be the Number that is the time value (UTC) identifying the current time.
+ 1. Return ToDateString(_now_).
+
+
+
+
+
+
Date ( )
+
This description applies only if the Date constructor is called with no arguments.
+
When the `Date` function is called the following steps are taken:
+
+ 1. Let _numberOfArgs_ be the number of arguments passed to this function call.
+ 1. Assert: _numberOfArgs_ = 0.
+ 1. If NewTarget is not *undefined*, then
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%DatePrototype%"`, « [[DateValue]] »).
+ 1. Set the [[DateValue]] internal slot of _O_ to the time value (UTC) identifying the current time.
+ 1. Return _O_.
+ 1. Else,
+ 1. Let _now_ be the Number that is the time value (UTC) identifying the current time.
+ 1. Return ToDateString(_now_).
+
+
+
+
+
+
+
Properties of the Date Constructor
+
The value of the [[Prototype]] internal slot of the Date constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is `7`), the Date constructor has the following properties:
+
+
+
+
Date.now ( )
+
The `now` function returns a Number value that is the time value designating the UTC date and time of the occurrence of the call to `now`.
+
+
+
+
+
Date.parse ( _string_ )
+
The `parse` function applies the ToString operator to its argument. If ToString results in an abrupt completion the Completion Record is immediately returned. Otherwise, `parse` interprets the resulting String as a date and time; it returns a Number, the UTC time value corresponding to the date and time. The String may be interpreted as a local time, a UTC time, or a time in some other time zone, depending on the contents of the String. The function first attempts to parse the format of the String according to the rules (including extended years) called out in Date Time String Format (). If the String does not conform to that format the function may fall back to any implementation-specific heuristics or implementation-specific date formats. Unrecognizable Strings or dates containing illegal element values in the format String shall cause `Date.parse` to return *NaN*.
+
If `x` is any Date object whose milliseconds amount is zero within a particular implementation of ECMAScript, then all of the following expressions should produce the same numeric value in that implementation, if all the properties referenced have their initial values:
is not required to produce the same Number value as the preceding three expressions and, in general, the value produced by `Date.parse` is implementation-dependent when given any String value that does not conform to the Date Time String Format () and that could not be produced in that implementation by the `toString` or `toUTCString` method.
+
+
+
+
+
Date.prototype
+
The initial value of `Date.prototype` is the intrinsic object %DatePrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
When the `UTC` function is called with fewer than two arguments, the behaviour is implementation-dependent. When the `UTC` function is called with two to seven arguments, it computes the date from _year_, _month_ and (optionally) _date_, _hours_, _minutes_, _seconds_ and _ms_. The following steps are taken:
+
+ 1. Let _y_ be ? ToNumber(_year_).
+ 1. Let _m_ be ? ToNumber(_month_).
+ 1. If _date_ is supplied, let _dt_ be ? ToNumber(_date_); else let _dt_ be 1.
+ 1. If _hours_ is supplied, let _h_ be ? ToNumber(_hours_); else let _h_ be 0.
+ 1. If _minutes_ is supplied, let _min_ be ? ToNumber(_minutes_); else let _min_ be 0.
+ 1. If _seconds_ is supplied, let _s_ be ? ToNumber(_seconds_); else let _s_ be 0.
+ 1. If _ms_ is supplied, let _milli_ be ? ToNumber(_ms_); else let _milli_ be 0.
+ 1. If _y_ is not *NaN* and 0 ≤ ToInteger(_y_) ≤ 99, let _yr_ be 1900+ToInteger(_y_); otherwise, let _yr_ be _y_.
+ 1. Return TimeClip(MakeDate(MakeDay(_yr_, _m_, _dt_), MakeTime(_h_, _min_, _s_, _milli_))).
+
+
+
The `UTC` function differs from the `Date` constructor in two ways: it returns a time value as a Number, rather than creating a Date object, and it interprets the arguments in UTC rather than as local time.
+
+
+
+
+
+
+
Properties of the Date Prototype Object
+
The Date prototype object is the intrinsic object %DatePrototype%. The Date prototype object is itself an ordinary object. It is not a Date instance and does not have a [[DateValue]] internal slot.
+
The value of the [[Prototype]] internal slot of the Date prototype object is the intrinsic object %ObjectPrototype% ().
+
Unless explicitly defined otherwise, the methods of the Date prototype object defined below are not generic and the *this* value passed to them must be an object that has a [[DateValue]] internal slot that has been initialized to a time value.
+
The abstract operation thisTimeValue(_value_) performs the following steps:
+
+ 1. If Type(_value_) is Object and _value_ has a [[DateValue]] internal slot, then
+ 1. Return the value of _value_'s [[DateValue]] internal slot.
+ 1. Throw a *TypeError* exception.
+
+
In following descriptions of functions that are properties of the Date prototype object, the phrase “this Date object” refers to the object that is the *this* value for the invocation of the function. If the Type of the *this* value is not Object, a *TypeError* exception is thrown. The phrase “this time value” within the specification of a method refers to the result returned by calling the abstract operation thisTimeValue with the *this* value of the method invocation passed as the argument.
+
+
+
+
Date.prototype.constructor
+
The initial value of `Date.prototype.constructor` is the intrinsic object %Date%.
+
+
+
+
+
Date.prototype.getDate ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return DateFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getDay ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return WeekDay(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getFullYear ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return YearFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getHours ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return HourFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getMilliseconds ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return msFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getMinutes ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return MinFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getMonth ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return MonthFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getSeconds ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return SecFromTime(LocalTime(_t_)).
+
+
+
+
+
+
Date.prototype.getTime ( )
+
The following steps are performed:
+
+ 1. Return this time value.
+
+
+
+
+
+
Date.prototype.getTimezoneOffset ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return (_t_ - LocalTime(_t_)) / msPerMinute.
+
+
+
+
+
+
Date.prototype.getUTCDate ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return DateFromTime(_t_).
+
+
+
+
+
+
Date.prototype.getUTCDay ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return WeekDay(_t_).
+
+
+
+
+
+
Date.prototype.getUTCFullYear ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return YearFromTime(_t_).
+
+
+
+
+
+
Date.prototype.getUTCHours ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return HourFromTime(_t_).
+
+
+
+
+
+
Date.prototype.getUTCMilliseconds ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return msFromTime(_t_).
+
+
+
+
+
+
Date.prototype.getUTCMinutes ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return MinFromTime(_t_).
+
+
+
+
+
+
Date.prototype.getUTCMonth ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return MonthFromTime(_t_).
+
+
+
+
+
+
Date.prototype.getUTCSeconds ( )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return SecFromTime(_t_).
+
+
+
+
+
+
Date.prototype.setDate ( _date_ )
+
The following steps are performed:
+
+ 1. Let _t_ be ? LocalTime(this time value).
+ 1. Let _dt_ be ? ToNumber(_date_).
+ 1. Let _newDate_ be MakeDate(MakeDay(YearFromTime(_t_), MonthFromTime(_t_), _dt_), TimeWithinDay(_t_)).
+ 1. Let _u_ be TimeClip(UTC(_newDate_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
+
+
+
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, let _t_ be *+0*; otherwise, let _t_ be LocalTime(_t_).
+ 1. Let _y_ be ? ToNumber(_year_).
+ 1. If _month_ is not specified, let _m_ be MonthFromTime(_t_); otherwise, let _m_ be ? ToNumber(_month_).
+ 1. If _date_ is not specified, let _dt_ be DateFromTime(_t_); otherwise, let _dt_ be ? ToNumber(_date_).
+ 1. Let _newDate_ be MakeDate(MakeDay(_y_, _m_, _dt_), TimeWithinDay(_t_)).
+ 1. Let _u_ be TimeClip(UTC(_newDate_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
If _month_ is not specified, this method behaves as if _month_ were specified with the value `getMonth()`. If _date_ is not specified, it behaves as if _date_ were specified with the value `getDate()`.
+
+ 1. Let _t_ be ? LocalTime(this time value).
+ 1. Let _h_ be ? ToNumber(_hour_).
+ 1. If _min_ is not specified, let _m_ be MinFromTime(_t_); otherwise, let _m_ be ? ToNumber(_min_).
+ 1. If _sec_ is not specified, let _s_ be SecFromTime(_t_); otherwise, let _s_ be ? ToNumber(_sec_).
+ 1. If _ms_ is not specified, let _milli_ be msFromTime(_t_); otherwise, let _milli_ be ? ToNumber(_ms_).
+ 1. Let _date_ be MakeDate(Day(_t_), MakeTime(_h_, _m_, _s_, _milli_)).
+ 1. Let _u_ be TimeClip(UTC(_date_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
If _min_ is not specified, this method behaves as if _min_ were specified with the value `getMinutes()`. If _sec_ is not specified, it behaves as if _sec_ were specified with the value `getSeconds()`. If _ms_ is not specified, it behaves as if _ms_ were specified with the value `getMilliseconds()`.
+
+
+
+
+
+
Date.prototype.setMilliseconds ( _ms_ )
+
The following steps are performed:
+
+ 1. Let _t_ be ? LocalTime(this time value).
+ 1. Let _ms_ be ? ToNumber(_ms_).
+ 1. Let _time_ be MakeTime(HourFromTime(_t_), MinFromTime(_t_), SecFromTime(_t_), _ms_).
+ 1. Let _u_ be TimeClip(UTC(MakeDate(Day(_t_), _time_))).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
+
+
+
+
+ 1. Let _t_ be ? LocalTime(this time value).
+ 1. Let _m_ be ? ToNumber(_min_).
+ 1. If _sec_ is not specified, let _s_ be SecFromTime(_t_); otherwise, let _s_ be ? ToNumber(_sec_).
+ 1. If _ms_ is not specified, let _milli_ be msFromTime(_t_); otherwise, let _milli_ be ? ToNumber(_ms_).
+ 1. Let _date_ be MakeDate(Day(_t_), MakeTime(HourFromTime(_t_), _m_, _s_, _milli_)).
+ 1. Let _u_ be TimeClip(UTC(_date_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
If _sec_ is not specified, this method behaves as if _sec_ were specified with the value `getSeconds()`. If _ms_ is not specified, this behaves as if _ms_ were specified with the value `getMilliseconds()`.
+
+
+
+
+
+
Date.prototype.setMonth ( _month_ [ , _date_ ] )
+
The following steps are performed:
+
+ 1. Let _t_ be ? LocalTime(this time value).
+ 1. Let _m_ be ? ToNumber(_month_).
+ 1. If _date_ is not specified, let _dt_ be DateFromTime(_t_); otherwise, let _dt_ be ? ToNumber(_date_).
+ 1. Let _newDate_ be MakeDate(MakeDay(YearFromTime(_t_), _m_, _dt_), TimeWithinDay(_t_)).
+ 1. Let _u_ be TimeClip(UTC(_newDate_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
If _date_ is not specified, this method behaves as if _date_ were specified with the value `getDate()`.
+
+
+
+
+
+
Date.prototype.setSeconds ( _sec_ [ , _ms_ ] )
+
The following steps are performed:
+
+ 1. Let _t_ be ? LocalTime(this time value).
+ 1. Let _s_ be ? ToNumber(_sec_).
+ 1. If _ms_ is not specified, let _milli_ be msFromTime(_t_); otherwise, let _milli_ be ? ToNumber(_ms_).
+ 1. Let _date_ be MakeDate(Day(_t_), MakeTime(HourFromTime(_t_), MinFromTime(_t_), _s_, _milli_)).
+ 1. Let _u_ be TimeClip(UTC(_date_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _u_.
+ 1. Return _u_.
+
+
+
If _ms_ is not specified, this method behaves as if _ms_ were specified with the value `getMilliseconds()`.
+
+
+
+
+
+
Date.prototype.setTime ( _time_ )
+
The following steps are performed:
+
+ 1. Let _valueNotUsed_ be this time value.
+ 1. ReturnIfAbrupt(_valueNotUsed_).
+ 1. Let _t_ be ? ToNumber(_time_).
+ 1. Let _v_ be TimeClip(_t_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
+
+
+
Date.prototype.setUTCDate ( _date_ )
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. Let _dt_ be ? ToNumber(_date_).
+ 1. Let _newDate_ be MakeDate(MakeDay(YearFromTime(_t_), MonthFromTime(_t_), _dt_), TimeWithinDay(_t_)).
+ 1. Let _v_ be TimeClip(_newDate_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
+
+
+
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, let _t_ be *+0*.
+ 1. Let _y_ be ? ToNumber(_year_).
+ 1. If _month_ is not specified, let _m_ be MonthFromTime(_t_); otherwise, let _m_ be ? ToNumber(_month_).
+ 1. If _date_ is not specified, let _dt_ be DateFromTime(_t_); otherwise, let _dt_ be ? ToNumber(_date_).
+ 1. Let _newDate_ be MakeDate(MakeDay(_y_, _m_, _dt_), TimeWithinDay(_t_)).
+ 1. Let _v_ be TimeClip(_newDate_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
If _month_ is not specified, this method behaves as if _month_ were specified with the value `getUTCMonth()`. If _date_ is not specified, it behaves as if _date_ were specified with the value `getUTCDate()`.
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. Let _h_ be ? ToNumber(_hour_).
+ 1. If _min_ is not specified, let _m_ be MinFromTime(_t_); otherwise, let _m_ be ? ToNumber(_min_).
+ 1. If _sec_ is not specified, let _s_ be SecFromTime(_t_); otherwise, let _s_ be ? ToNumber(_sec_).
+ 1. If _ms_ is not specified, let _milli_ be msFromTime(_t_); otherwise, let _milli_ be ? ToNumber(_ms_).
+ 1. Let _newDate_ be MakeDate(Day(_t_), MakeTime(_h_, _m_, _s_, _milli_)).
+ 1. Let _v_ be TimeClip(_newDate_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
If _min_ is not specified, this method behaves as if _min_ were specified with the value `getUTCMinutes()`. If _sec_ is not specified, it behaves as if _sec_ were specified with the value `getUTCSeconds()`. If _ms_ is not specified, it behaves as if _ms_ were specified with the value `getUTCMilliseconds()`.
+
+
+
+
+
+
Date.prototype.setUTCMilliseconds ( _ms_ )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. Let _milli_ be ? ToNumber(_ms_).
+ 1. Let _time_ be MakeTime(HourFromTime(_t_), MinFromTime(_t_), SecFromTime(_t_), _milli_).
+ 1. Let _v_ be TimeClip(MakeDate(Day(_t_), _time_)).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
+
+
+
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. Let _m_ be ? ToNumber(_min_).
+ 1. If _sec_ is not specified, let _s_ be SecFromTime(_t_).
+ 1. Else,
+ 1. Let _s_ be ? ToNumber(_sec_).
+ 1. If _ms_ is not specified, let _milli_ be msFromTime(_t_).
+ 1. Else,
+ 1. Let _milli_ be ? ToNumber(_ms_).
+ 1. Let _date_ be MakeDate(Day(_t_), MakeTime(HourFromTime(_t_), _m_, _s_, _milli_)).
+ 1. Let _v_ be TimeClip(_date_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
If _sec_ is not specified, this method behaves as if _sec_ were specified with the value `getUTCSeconds()`. If _ms_ is not specified, it function behaves as if _ms_ were specified with the value return by `getUTCMilliseconds()`.
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. Let _m_ be ? ToNumber(_month_).
+ 1. If _date_ is not specified, let _dt_ be DateFromTime(_t_).
+ 1. Else,
+ 1. Let _dt_ be ? ToNumber(_date_).
+ 1. Let _newDate_ be MakeDate(MakeDay(YearFromTime(_t_), _m_, _dt_), TimeWithinDay(_t_)).
+ 1. Let _v_ be TimeClip(_newDate_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
If _date_ is not specified, this method behaves as if _date_ were specified with the value `getUTCDate()`.
+
+
+
+
+
+
Date.prototype.setUTCSeconds ( _sec_ [ , _ms_ ] )
+
The following steps are performed:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. Let _s_ be ? ToNumber(_sec_).
+ 1. If _ms_ is not specified, let _milli_ be msFromTime(_t_).
+ 1. Else,
+ 1. Let _milli_ be ? ToNumber(_ms_).
+ 1. Let _date_ be MakeDate(Day(_t_), MakeTime(HourFromTime(_t_), MinFromTime(_t_), _s_, _milli_)).
+ 1. Let _v_ be TimeClip(_date_).
+ 1. Set the [[DateValue]] internal slot of this Date object to _v_.
+ 1. Return _v_.
+
+
+
If _ms_ is not specified, this method behaves as if _ms_ were specified with the value `getUTCMilliseconds()`.
+
+
+
+
+
+
Date.prototype.toDateString ( )
+
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the “date” portion of the Date in the current time zone in a convenient, human-readable form.
+
+
+
+
+
Date.prototype.toISOString ( )
+
This function returns a String value representing the instance in time corresponding to this time value. The format of the String is the Date Time string format defined in . All fields are present in the String. The time zone is always UTC, denoted by the suffix Z. If this time value is not a finite Number or if the year is not a value that can be represented in that format (if necessary using extended year format), a *RangeError* exception is thrown.
+
+
+
+
+
Date.prototype.toJSON ( _key_ )
+
This function provides a String representation of a Date object for use by `JSON.stringify` ().
+
When the `toJSON` method is called with argument _key_, the following steps are taken:
+
+ 1. Let _O_ be ToObject(*this* value).
+ 1. Let _tv_ be ? ToPrimitive(_O_, hint Number).
+ 1. If Type(_tv_) is Number and _tv_ is not finite, return *null*.
+ 1. Return Invoke(_O_, `"toISOString"`).
+
+
+
The argument is ignored.
+
+
+
The `toJSON` function is intentionally generic; it does not require that its *this* value be a Date object. Therefore, it can be transferred to other kinds of objects for use as a method. However, it does require that any such object have a `toISOString` method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `Date.prototype.toLocaleDateString` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleDateString` method is used.
+
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the “date” portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.
+
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
The `length` property of the `toLocaleDateString` method is 0.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `Date.prototype.toLocaleString` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleString` method is used.
+
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.
+
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
The `length` property of the `toLocaleString` method is 0.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `Date.prototype.toLocaleTimeString` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleTimeString` method is used.
+
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the “time” portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.
+
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
The `length` property of the `toLocaleTimeString` method is 0.
+
+
+
+
+
Date.prototype.toString ( )
+
The following steps are performed:
+
+ 1. Let _O_ be this Date object.
+ 1. If _O_ does not have a [[DateValue]] internal slot, then
+ 1. Let _tv_ be *NaN*.
+ 1. Else,
+ 1. Let _tv_ be this time value.
+ 1. Return ToDateString(_tv_).
+
+
+
For any Date object `d` whose milliseconds amount is zero, the result of `Date.parse(d.toString())` is equal to `d.valueOf()`. See .
+
+
+
The `toString` function is intentionally generic; it does not require that its *this* value be a Date object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
Runtime Semantics: ToDateString(_tv_)
+
The following steps are performed:
+
+ 1. Assert: Type(_tv_) is Number.
+ 1. If _tv_ is *NaN*, return `"Invalid Date"`.
+ 1. Return an implementation-dependent String value that represents _tv_ as a date and time in the current time zone using a convenient, human-readable form.
+
+
+
+
+
+
+
Date.prototype.toTimeString ( )
+
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent the “time” portion of the Date in the current time zone in a convenient, human-readable form.
+
+
+
+
+
Date.prototype.toUTCString ( )
+
This function returns a String value. The contents of the String are implementation-dependent, but are intended to represent this time value in a convenient, human-readable form in UTC.
+
+
The intent is to produce a String representation of a date that is more readable than the format specified in . It is not essential that the chosen format be unambiguous or easily machine parsable. If an implementation does not have a preferred human-readable format it is recommended to use the format defined in but with a space rather than a `"T"` used to separate the date and time elements.
+
+
+
+
+
+
Date.prototype.valueOf ( )
+
The following steps are performed:
+
+ 1. Return this time value.
+
+
+
+
+
+
Date.prototype [ @@toPrimitive ] ( _hint_ )
+
This function is called by ECMAScript language operators to convert a Date object to a primitive value. The allowed values for _hint_ are `"default"`, `"number"`, and `"string"`. Date objects, are unique among built-in ECMAScript object in that they treat `"default"` as being equivalent to `"string"`, All other built-in ECMAScript objects treat `"default"` as being equivalent to `"number"`.
+
When the `@@toPrimitive` method is called with argument _hint_, the following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _hint_ is the String value `"string"` or the String value `"default"` , then
+ 1. Let _tryFirst_ be `"string"`.
+ 1. Else if _hint_ is the String value `"number"`, then
+ 1. Let _tryFirst_ be `"number"`.
+ 1. Else, throw a *TypeError* exception.
+ 1. Return OrdinaryToPrimitive(_O_, _tryFirst_).
+
+
The value of the `name` property of this function is `"[Symbol.toPrimitive]"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Date Instances
+
Date instances are ordinary objects that inherit properties from the Date prototype object. Date instances also have a [[DateValue]] internal slot. The [[DateValue]] internal slot is the time value represented by this Date object.
+
+
+
+
+
+
+
Text Processing
+
+
+
+
String Objects
+
+
+
+
The String Constructor
+
The String constructor is the %String% intrinsic object and the initial value of the `String` property of the global object. When called as a constructor it creates and initializes a new String object. When `String` is called as a function rather than as a constructor, it performs a type conversion.
+
The `String` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `String` behaviour must include a `super` call to the `String` constructor to create and initialize the subclass instance with a [[StringData]] internal slot.
+
+
+
+
String ( _value_ )
+
When `String` is called with argument _value_, the following steps are taken:
+
+ 1. If no arguments were passed to this function invocation, let _s_ be `""`.
+ 1. Else,
+ 1. If NewTarget is *undefined* and Type(_value_) is Symbol, return SymbolDescriptiveString(_value_).
+ 1. Let _s_ be ? ToString(_value_).
+ 1. If NewTarget is *undefined*, return _s_.
+ 1. Return StringCreate(_s_, GetPrototypeFromConstructor(NewTarget, `"%StringPrototype%"`)).
+
+
+
+
+
+
+
Properties of the String Constructor
+
The value of the [[Prototype]] internal slot of the String constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 1), the String constructor has the following properties:
+
+
+
+
String.fromCharCode ( ..._codeUnits_ )
+
The `String.fromCharCode` function may be called with any number of arguments which form the rest parameter _codeUnits_. The following steps are taken:
+
+ 1. Let _codeUnits_ be a List containing the arguments passed to this function.
+ 1. Let _length_ be the number of elements in _codeUnits_.
+ 1. Let _elements_ be a new List.
+ 1. Let _nextIndex_ be 0.
+ 1. Repeat while _nextIndex_ < _length_
+ 1. Let _next_ be _codeUnits_[_nextIndex_].
+ 1. Let _nextCU_ be ? ToUint16(_next_).
+ 1. Append _nextCU_ to the end of _elements_.
+ 1. Let _nextIndex_ be _nextIndex_ + 1.
+ 1. Return the String value whose elements are, in order, the elements in the List _elements_. If _length_ is 0, the empty string is returned.
+
+
The `length` property of the `fromCharCode` function is 1.
+
+
+
+
+
String.fromCodePoint ( ..._codePoints_ )
+
The `String.fromCodePoint` function may be called with any number of arguments which form the rest parameter _codePoints_. The following steps are taken:
+
+ 1. Let _codePoints_ be a List containing the arguments passed to this function.
+ 1. Let _length_ be the number of elements in _codePoints_.
+ 1. Let _elements_ be a new List.
+ 1. Let _nextIndex_ be 0.
+ 1. Repeat while _nextIndex_ < _length_
+ 1. Let _next_ be _codePoints_[_nextIndex_].
+ 1. Let _nextCP_ be ? ToNumber(_next_).
+ 1. If SameValue(_nextCP_, ToInteger(_nextCP_)) is *false*, throw a *RangeError* exception.
+ 1. If _nextCP_ < 0 or _nextCP_ > 0x10FFFF, throw a *RangeError* exception.
+ 1. Append the elements of the UTF16Encoding () of _nextCP_ to the end of _elements_.
+ 1. Let _nextIndex_ be _nextIndex_ + 1.
+ 1. Return the String value whose elements are, in order, the elements in the List _elements_. If _length_ is 0, the empty string is returned.
+
+
The `length` property of the `fromCodePoint` function is 1.
+
+
+
+
+
String.prototype
+
The initial value of `String.prototype` is the intrinsic object %StringPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
String.raw ( _template_ , ..._substitutions_ )
+
The `String.raw` function may be called with a variable number of arguments. The first argument is _template_ and the remainder of the arguments form the List _substitutions_. The following steps are taken:
+
+ 1. Let _substitutions_ be a List consisting of all of the arguments passed to this function, starting with the second argument. If fewer than two arguments were passed, the List is empty.
+ 1. Let _numberOfSubstitutions_ be the number of elements in _substitutions_.
+ 1. Let _cooked_ be ? ToObject(_template_).
+ 1. Let _raw_ be ? ToObject(? Get(_cooked_, `"raw"`)).
+ 1. Let _literalSegments_ be ? ToLength(? Get(_raw_, `"length"`)).
+ 1. If _literalSegments_ ≤ 0, return the empty string.
+ 1. Let _stringElements_ be a new List.
+ 1. Let _nextIndex_ be 0.
+ 1. Repeat
+ 1. Let _nextKey_ be ToString(_nextIndex_).
+ 1. Let _nextSeg_ be ? ToString(? Get(_raw_, _nextKey_)).
+ 1. Append in order the code unit elements of _nextSeg_ to the end of _stringElements_.
+ 1. If _nextIndex_ + 1 = _literalSegments_, then
+ 1. Return the String value whose code units are, in order, the elements in the List _stringElements_. If _stringElements_ has no elements, the empty string is returned.
+ 1. If _nextIndex_ < _numberOfSubstitutions_, let _next_ be _substitutions_[_nextIndex_].
+ 1. Else, let _next_ be the empty String.
+ 1. Let _nextSub_ be ? ToString(_next_).
+ 1. Append in order the code unit elements of _nextSub_ to the end of _stringElements_.
+ 1. Let _nextIndex_ be _nextIndex_ + 1.
+
+
The `length` property of the `raw` function is 1.
+
+
String.raw is intended for use as a tag function of a Tagged Template (). When called as such, the first argument will be a well formed template object and the rest parameter will contain the substitution values.
+
+
+
+
+
+
+
Properties of the String Prototype Object
+
The String prototype object is the intrinsic object %StringPrototype%. The String prototype object is an ordinary object. The String prototype is itself a String object; it has a [[StringData]] internal slot with the value *""*.
+
The value of the [[Prototype]] internal slot of the String prototype object is the intrinsic object %ObjectPrototype% ().
+
Unless explicitly stated otherwise, the methods of the String prototype object defined below are not generic and the *this* value passed to them must be either a String value or an object that has a [[StringData]] internal slot that has been initialized to a String value.
+
The abstract operation thisStringValue(_value_) performs the following steps:
+
+ 1. If Type(_value_) is String, return _value_.
+ 1. If Type(_value_) is Object and _value_ has a [[StringData]] internal slot, then
+ 1. Assert: _value_'s [[StringData]] internal slot is a String value.
+ 1. Return the value of _value_'s [[StringData]] internal slot.
+ 1. Throw a *TypeError* exception.
+
+
The phrase “this String value” within the specification of a method refers to the result returned by calling the abstract operation thisStringValue with the *this* value of the method invocation passed as the argument.
+
+
+
+
String.prototype.charAt ( _pos_ )
+
+
Returns a single element String containing the code unit at index _pos_ in the String value resulting from converting this object to a String. If there is no element at that index, the result is the empty String. The result is a String value, not a String object.
+
If `pos` is a value of Number type that is an integer, then the result of `x.charAt(pos)` is equal to the result of `x.substring(pos, pos+1)`.
+
+
When the `charAt` method is called with one argument _pos_, the following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _position_ be ? ToInteger(_pos_).
+ 1. Let _size_ be the number of elements in _S_.
+ 1. If _position_ < 0 or _position_ ≥ _size_, return the empty String.
+ 1. Return a String of length 1, containing one code unit from _S_, namely the code unit at index _position_.
+
+
+
The `charAt` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.charCodeAt ( _pos_ )
+
+
Returns a Number (a nonnegative integer less than 216) that is the code unit value of the string element at index _pos_ in the String resulting from converting this object to a String. If there is no element at that index, the result is *NaN*.
+
+
When the `charCodeAt` method is called with one argument _pos_, the following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _position_ be ? ToInteger(_pos_).
+ 1. Let _size_ be the number of elements in _S_.
+ 1. If _position_ < 0 or _position_ ≥ _size_, return *NaN*.
+ 1. Return a value of Number type, whose value is the code unit value of the element at index _position_ in the String _S_.
+
+
+
The `charCodeAt` function is intentionally generic; it does not require that its *this* value be a String object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.codePointAt ( _pos_ )
+
+
Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point value of the UTF-16 encoded code point () starting at the string element at index _pos_ in the String resulting from converting this object to a String. If there is no element at that index, the result is *undefined*. If a valid UTF-16 surrogate pair does not begin at _pos_, the result is the code unit at _pos_.
+
+
When the `codePointAt` method is called with one argument _pos_, the following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _position_ be ? ToInteger(_pos_).
+ 1. Let _size_ be the number of elements in _S_.
+ 1. If _position_ < 0 or _position_ ≥ _size_, return *undefined*.
+ 1. Let _first_ be the code unit value of the element at index _position_ in the String _S_.
+ 1. If _first_ < 0xD800 or _first_ > 0xDBFF or _position_+1 = _size_, return _first_.
+ 1. Let _second_ be the code unit value of the element at index _position_+1 in the String _S_.
+ 1. If _second_ < 0xDC00 or _second_ > 0xDFFF, return _first_.
+ 1. Return UTF16Decode(_first_, _second_).
+
+
+
The `codePointAt` function is intentionally generic; it does not require that its *this* value be a String object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.concat ( ..._args_ )
+
+
When the `concat` method is called it returns a String consisting of the code units of the `this` object (converted to a String) followed by the code units of each of the arguments converted to a String. The result is a String value, not a String object.
+
+
When the `concat` method is called with zero or more arguments the following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _args_ be a List whose elements are the arguments passed to this function.
+ 1. Let _R_ be _S_.
+ 1. Repeat, while _args_ is not empty
+ 1. Remove the first element from _args_ and let _next_ be the value of that element.
+ 1. Let _nextString_ be ? ToString(_next_).
+ 1. Let _R_ be the String value consisting of the code units of the previous value of _R_ followed by the code units of _nextString_.
+ 1. Return _R_.
+
+
The `length` property of the `concat` method is 1.
+
+
The `concat` function is intentionally generic; it does not require that its *this* value be a String object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.constructor
+
The initial value of `String.prototype.constructor` is the intrinsic object %String%.
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _isRegExp_ be ? IsRegExp(_searchString_).
+ 1. If _isRegExp_ is *true*, throw a *TypeError* exception.
+ 1. Let _searchStr_ be ? ToString(_searchString_).
+ 1. Let _len_ be the number of elements in _S_.
+ 1. If _endPosition_ is *undefined*, let _pos_ be _len_, else let _pos_ be ? ToInteger(_endPosition_).
+ 1. Let _end_ be min(max(_pos_, 0), _len_).
+ 1. Let _searchLength_ be the number of elements in _searchStr_.
+ 1. Let _start_ be _end_ - _searchLength_.
+ 1. If _start_ is less than 0, return *false*.
+ 1. If the sequence of elements of _S_ starting at _start_ of length _searchLength_ is the same as the full element sequence of _searchStr_, return *true*.
+ 1. Otherwise, return *false*.
+
+
The `length` property of the `endsWith` method is 1.
+
+
Returns *true* if the sequence of elements of _searchString_ converted to a String is the same as the corresponding elements of this object (converted to a String) starting at _endPosition_ - length(this). Otherwise returns *false*.
+
+
+
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
+
+
+
The `endsWith` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
The `includes` method takes two arguments, _searchString_ and _position_, and performs the following steps:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _isRegExp_ be ? IsRegExp(_searchString_).
+ 1. If _isRegExp_ is *true*, throw a *TypeError* exception.
+ 1. Let _searchStr_ be ? ToString(_searchString_).
+ 1. Let _pos_ be ? ToInteger(_position_). (If _position_ is *undefined*, this step produces the value 0.)
+ 1. Let _len_ be the number of elements in _S_.
+ 1. Let _start_ be min(max(_pos_, 0), _len_).
+ 1. Let _searchLen_ be the number of elements in _searchStr_.
+ 1. If there exists any integer _k_ not smaller than _start_ such that _k_ + _searchLen_ is not greater than _len_, and for all nonnegative integers _j_ less than _searchLen_, the code unit at index _k_+_j_ of _S_ is the same as the code unit at index _j_ of _searchStr_, return *true*; but if there is no such integer _k_, return *false*.
+
+
The `length` property of the `includes` method is 1.
+
+
If _searchString_ appears as a substring of the result of converting this object to a String, at one or more indices that are greater than or equal to _position_, return *true*; otherwise, returns *false*. If _position_ is *undefined*, 0 is assumed, so as to search all of the String.
+
+
+
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
+
+
+
The `includes` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
If _searchString_ appears as a substring of the result of converting this object to a String, at one or more indices that are greater than or equal to _position_, then the smallest such index is returned; otherwise, `-1` is returned. If _position_ is *undefined*, 0 is assumed, so as to search all of the String.
+
+
The `indexOf` method takes two arguments, _searchString_ and _position_, and performs the following steps:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _searchStr_ be ? ToString(_searchString_).
+ 1. Let _pos_ be ? ToInteger(_position_). (If _position_ is *undefined*, this step produces the value 0.)
+ 1. Let _len_ be the number of elements in _S_.
+ 1. Let _start_ be min(max(_pos_, 0), _len_).
+ 1. Let _searchLen_ be the number of elements in _searchStr_.
+ 1. Return the smallest possible integer _k_ not smaller than _start_ such that _k_+ _searchLen_ is not greater than _len_, and for all nonnegative integers _j_ less than _searchLen_, the code unit at index _k_+_j_ of _S_ is the same as the code unit at index _j_ of _searchStr_; but if there is no such integer _k_, return the value `-1`.
+
+
The `length` property of the `indexOf` method is 1.
+
+
The `indexOf` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
If _searchString_ appears as a substring of the result of converting this object to a String at one or more indices that are smaller than or equal to _position_, then the greatest such index is returned; otherwise, `-1` is returned. If _position_ is *undefined*, the length of the String value is assumed, so as to search all of the String.
+
+
The `lastIndexOf` method takes two arguments, _searchString_ and _position_, and performs the following steps:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _searchStr_ be ? ToString(_searchString_).
+ 1. Let _numPos_ be ? ToNumber(_position_). (If _position_ is *undefined*, this step produces the value *NaN*.)
+ 1. If _numPos_ is *NaN*, let _pos_ be *+∞*; otherwise, let _pos_ be ToInteger(_numPos_).
+ 1. Let _len_ be the number of elements in _S_.
+ 1. Let _start_ be min(max(_pos_, 0), _len_).
+ 1. Let _searchLen_ be the number of elements in _searchStr_.
+ 1. Return the largest possible nonnegative integer _k_ not larger than _start_ such that _k_+ _searchLen_ is not greater than _len_, and for all nonnegative integers _j_ less than _searchLen_, the code unit at index _k_+_j_ of _S_ is the same as the code unit at index _j_ of _searchStr_; but if there is no such integer _k_, return the value `-1`.
+
+
The `length` property of the `lastIndexOf` method is 1.
+
+
The `lastIndexOf` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `localeCompare` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `localeCompare` method is used.
+
When the `localeCompare` method is called with argument _that_, it returns a Number other than *NaN* that represents the result of a locale-sensitive String comparison of the *this* value (converted to a String) with _that_ (converted to a String). The two Strings are _S_ and _That_. The two Strings are compared in an implementation-defined fashion. The result is intended to order String values in the sort order specified by a host default locale, and will be negative, zero, or positive, depending on whether _S_ comes before _That_ in the sort order, the Strings are equal, or _S_ comes after _That_ in the sort order, respectively.
+
Before performing the comparisons, the following steps are performed to prepare the Strings:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _That_ be ? ToString(_that_).
+
+
The meaning of the optional second and third parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not assign any other interpretation to those parameter positions.
+
The `localeCompare` method, if considered as a function of two arguments *this* and _that_, is a consistent comparison function (as defined in ) on the set of all Strings.
+
The actual return values are implementation-defined to permit implementers to encode additional information in the value, but the function is required to define a total ordering on all Strings. This function must treat Strings that are canonically equivalent according to the Unicode standard as identical and must return `0` when comparing Strings that are considered canonically equivalent.
+
The `length` property of the `localeCompare` method is 1.
+
+
The `localeCompare` method itself is not directly suitable as an argument to `Array.prototype.sort` because the latter requires a function of two arguments.
+
+
+
This function is intended to rely on whatever language-sensitive comparison functionality is available to the ECMAScript environment from the host environment, and to compare according to the rules of the host environment's current locale. However, regardless of the host provided comparison capabilities, this function must treat Strings that are canonically equivalent according to the Unicode standard as identical. It is recommended that this function should not honour Unicode compatibility equivalences or decompositions. For a definition and discussion of canonical equivalence see the Unicode Standard, chapters 2 and 3, as well as Unicode Standard Annex #15, Unicode Normalization Forms (http://www.unicode.org/reports/tr15/) and Unicode Technical Note #5, Canonical Equivalence in Applications (http://www.unicode.org/notes/tn5/). Also see Unicode Technical Standard #10, Unicode Collation Algorithm (http://www.unicode.org/reports/tr10/).
+
+
+
The `localeCompare` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.match ( _regexp_ )
+
When the `match` method is called with argument _regexp_, the following steps are taken:
+
+ 1. Let _O_ be ? RequireObjectCoercible(*this* value).
+ 1. If _regexp_ is neither *undefined* nor *null*, then
+ 1. Let _matcher_ be ? GetMethod(_regexp_, @@match).
+ 1. If _matcher_ is not *undefined*, then
+ 1. Return Call(_matcher_, _regexp_, « _O_ »).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _rx_ be ? RegExpCreate(_regexp_, *undefined*) (see ).
+ 1. Return Invoke(_rx_, @@match, « _S_ »).
+
+
+
The `match` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.normalize ( [ _form_ ] )
+
When the `normalize` method is called with one argument _form_, the following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. If _form_ is not provided or _form_ is *undefined*, let _form_ be `"NFC"`.
+ 1. Let _f_ be ? ToString(_form_).
+ 1. If _f_ is not one of `"NFC"`, `"NFD"`, `"NFKC"`, or `"NFKD"`, throw a *RangeError* exception.
+ 1. Let _ns_ be the String value that is the result of normalizing _S_ into the normalization form named by _f_ as specified in http://www.unicode.org/reports/tr15/tr15-29.html.
+ 1. Return _ns_.
+
+
The `length` property of the `normalize` method is 0.
+
+
The `normalize` function is intentionally generic; it does not require that its *this* value be a String object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.repeat ( _count_ )
+
The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _n_ be ? ToInteger(_count_).
+ 1. If _n_ < 0, throw a *RangeError* exception.
+ 1. If _n_ is *+∞*, throw a *RangeError* exception.
+ 1. Let _T_ be a String value that is made from _n_ copies of _S_ appended together. If _n_ is 0, _T_ is the empty String.
+ 1. Return _T_.
+
+
+
This method creates a String consisting of the code units of the `this` object (converted to String) repeated _count_ times.
+
+
+
The `repeat` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
When the `replace` method is called with arguments _searchValue_ and _replaceValue_ the following steps are taken:
+
+ 1. Let _O_ be ? RequireObjectCoercible(*this* value).
+ 1. If _searchValue_ is neither *undefined* nor *null*, then
+ 1. Let _replacer_ be ? GetMethod(_searchValue_, @@replace).
+ 1. If _replacer_ is not *undefined*, then
+ 1. Return Call(_replacer_, _searchValue_, « _O_, _replaceValue_ »).
+ 1. Let _string_ be ? ToString(_O_).
+ 1. Let _searchString_ be ? ToString(_searchValue_).
+ 1. Let _functionalReplace_ be IsCallable(_replaceValue_).
+ 1. If _functionalReplace_ is *false*, then
+ 1. Let _replaceValue_ be ? ToString(_replaceValue_).
+ 1. Search _string_ for the first occurrence of _searchString_ and let _pos_ be the index within _string_ of the first code unit of the matched substring and let _matched_ be _searchString_. If no occurrences of _searchString_ were found, return _string_.
+ 1. If _functionalReplace_ is *true*, then
+ 1. Let _replValue_ be Call(_replaceValue_, *undefined*,« _matched_, _pos_, and _string_ »).
+ 1. Let _replStr_ be ? ToString(_replValue_).
+ 1. Else,
+ 1. Let _captures_ be an empty List.
+ 1. Let _replStr_ be GetSubstitution(_matched_, _string_, _pos_, _captures_, _replaceValue_).
+ 1. Let _tailPos_ be _pos_ + the number of code units in _matched_.
+ 1. Let _newString_ be the String formed by concatenating the first _pos_ code units of _string_, _replStr_, and the trailing substring of _string_ starting at index _tailPos_. If _pos_ is 0, the first element of the concatenation will be the empty String.
+ 1. Return _newString_.
+
+
+
The `replace` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
The abstract operation GetSubstitution performs the following steps:
+
+ 1. Assert: Type(_matched_) is String.
+ 1. Let _matchLength_ be the number of code units in _matched_.
+ 1. Assert: Type(_str_) is String.
+ 1. Let _stringLength_ be the number of code units in _str_.
+ 1. Assert: _position_ is a nonnegative integer.
+ 1. Assert: _position_ ≤ _stringLength_.
+ 1. Assert: _captures_ is a possibly empty List of Strings.
+ 1. Assert: Type( _replacement_) is String.
+ 1. Let _tailPos_ be _position_ + _matchLength_.
+ 1. Let _m_ be the number of elements in _captures_.
+ 1. Let _result_ be a String value derived from _replacement_ by copying code unit elements from _replacement_ to _result_ while performing replacements as specified in . These `$` replacements are done left-to-right, and, once such a replacement is performed, the new replacement text is not subject to further replacements.
+ 1. Return _result_.
+
+
+
+
+
+
+ Code units
+
+
+ Unicode Characters
+
+
+ Replacement text
+
+
+
+
+ 0x0024, 0x0024
+
+
+ `$$`
+
+
+ `$`
+
+
+
+
+ 0x0024, 0x0026
+
+
+ `$&`
+
+
+ _matched_
+
+
+
+
+ 0x0024, 0x0060
+
+
+ $`
+
+
+ If _position_ is 0, the replacement is the empty String. Otherwise the replacement is the substring of _str_ that starts at index 0 and whose last code unit is at index _position_ -1.
+
+
+
+
+ 0x0024, 0x0027
+
+
+ `$'`
+
+
+ If _tailPos_ ≥ _stringLength_, the replacement is the empty String. Otherwise the replacement is the substring of _str_ that starts at index _tailPos_ and continues to the end of _str_.
+
+
+
+
+ 0x0024, N
+
+ Where
+
+ 0x0031 ≤ N ≤ 0x0039
+
+
+ `$n` where
+
+ `n` is one of `1 2 3 4 5 6 7 8 9` and `$n` is not followed by a decimal digit
+
+
+ The _n_th element of _captures_, where _n_ is a single digit in the range 1 to 9. If _n_≤_m_ and the _n_th element of _captures_ is *undefined*, use the empty String instead. If _n_>_m_, the result is implementation-defined.
+
+
+
+
+ 0x0024, N, N
+
+ Where
+
+ 0x0030 ≤ N ≤ 0x0039
+
+
+ `$nn` where
+
+ `n` is one of `0 1 2 3 4 5 6 7 8 9`
+
+
+ The _nn_th element of _captures_, where _nn_ is a two-digit decimal number in the range 01 to 99. If _nn_≤_m_ and the _nn_th element of _captures_ is *undefined*, use the empty String instead. If _nn_ is 00 or _nn_>_m_, the result is implementation-defined.
+
+
+
+
+ 0x0024
+
+
+ `$` in any context that does not match any of the above.
+
+
+ `$`
+
+
+
+
+
+
+
+
+
+
+
String.prototype.search ( _regexp_ )
+
When the search method is called with argument _regexp_, the following steps are taken:
+
+ 1. Let _O_ be ? RequireObjectCoercible(*this* value).
+ 1. If _regexp_ is neither *undefined* nor *null*, then
+ 1. Let _searcher_ be ? GetMethod(_regexp_, @@search).
+ 1. If _searcher_ is not *undefined* , then
+ 1. Return Call(_searcher_, _regexp_, « _O_ »).
+ 1. Let _string_ be ? ToString(_O_).
+ 1. Let _rx_ be ? RegExpCreate(_regexp_, *undefined*) (see ).
+ 1. Return Invoke(_rx_, @@search, « _string_ »).
+
+
+
The `search` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.slice ( _start_, _end_ )
+
The `slice` method takes two arguments, _start_ and _end_, and returns a substring of the result of converting this object to a String, starting from index _start_ and running to, but not including, index _end_ (or through the end of the String if _end_ is *undefined*). If _start_ is negative, it is treated as _sourceLength_+_start_ where _sourceLength_ is the length of the String. If _end_ is negative, it is treated as _sourceLength_+_end_ where _sourceLength_ is the length of the String. The result is a String value, not a String object. The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _len_ be the number of elements in _S_.
+ 1. Let _intStart_ be ? ToInteger(_start_).
+ 1. If _end_ is *undefined*, let _intEnd_ be _len_; else let _intEnd_ be ? ToInteger(_end_).
+ 1. If _intStart_ < 0, let _from_ be max(_len_ + _intStart_,0); otherwise let _from_ be min(_intStart_, _len_).
+ 1. If _intEnd_ < 0, let _to_ be max(_len_ + _intEnd_,0); otherwise let _to_ be min(_intEnd_, _len_).
+ 1. Let _span_ be max(_to_ - _from_,0).
+ 1. Return a String value containing _span_ consecutive elements from _S_ beginning with the element at index _from_.
+
+
+
The `slice` function is intentionally generic; it does not require that its *this* value be a String object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.split ( _separator_, _limit_ )
+
Returns an Array object into which substrings of the result of converting this object to a String have been stored. The substrings are determined by searching from left to right for occurrences of _separator_; these occurrences are not part of any substring in the returned array, but serve to divide up the String value. The value of _separator_ may be a String of any length or it may be an object, such as an RegExp, that has a @@split method.
+
When the `split` method is called, the following steps are taken:
+
+ 1. Let _O_ be ? RequireObjectCoercible(*this* value).
+ 1. If _separator_ is neither *undefined* nor *null*, then
+ 1. Let _splitter_ be ? GetMethod(_separator_, @@split).
+ 1. If _splitter_ is not *undefined* , then
+ 1. Return Call(_splitter_, _separator_, « _O_, _limit_ »).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _A_ be ArrayCreate(0).
+ 1. Let _lengthA_ be 0.
+ 1. If _limit_ is *undefined*, let _lim_ be 232-1; else let _lim_ be ? ToUint32(_limit_).
+ 1. Let _s_ be the number of elements in _S_.
+ 1. Let _p_ be 0.
+ 1. Let _R_ be ? ToString(_separator_).
+ 1. If _lim_ = 0, return _A_.
+ 1. If _separator_ is *undefined*, then
+ 1. Perform CreateDataProperty(_A_, `"0"`, _S_).
+ 1. Assert: The above call will never result in an abrupt completion.
+ 1. Return _A_.
+ 1. If _s_ = 0, then
+ 1. Let _z_ be SplitMatch(_S_, 0, _R_).
+ 1. If _z_ is not *false*, return _A_.
+ 1. Perform CreateDataProperty(_A_, `"0"`, _S_).
+ 1. Assert: The above call will never result in an abrupt completion.
+ 1. Return _A_.
+ 1. Let _q_ be _p_.
+ 1. Repeat, while _q_ ≠ _s_
+ 1. Let _e_ be SplitMatch(_S_, _q_, _R_).
+ 1. If _e_ is *false*, let _q_ be _q_+1.
+ 1. Else _e_ is an integer index into _S_,
+ 1. If _e_ = _p_, let _q_ be _q_+1.
+ 1. Else _e_ ≠ _p_,
+ 1. Let _T_ be a String value equal to the substring of _S_ consisting of the code units at indices _p_ (inclusive) through _q_ (exclusive).
+ 1. Perform CreateDataProperty(_A_, ToString(_lengthA_), _T_).
+ 1. Assert: The above call will never result in an abrupt completion.
+ 1. Increment _lengthA_ by 1.
+ 1. If _lengthA_ = _lim_, return _A_.
+ 1. Let _p_ be _e_.
+ 1. Let _q_ be _p_.
+ 1. Let _T_ be a String value equal to the substring of _S_ consisting of the code units at indices _p_ (inclusive) through _s_ (exclusive).
+ 1. Perform CreateDataProperty(_A_, ToString(_lengthA_), _T_).
+ 1. Assert: The above call will never result in an abrupt completion.
+ 1. Return _A_.
+
+
+
The value of _separator_ may be an empty String, an empty regular expression, or a regular expression that can match an empty String. In this case, _separator_ does not match the empty substring at the beginning or end of the input String, nor does it match the empty substring at the end of the previous separator match. (For example, if _separator_ is the empty String, the String is split up into individual code unit elements; the length of the result array equals the length of the String, and each substring contains one code unit.) If _separator_ is a regular expression, only the first match at a given index of the *this* String is considered, even if backtracking could yield a non-empty-substring match at that index. (For example, `"ab".split(/a*?/)` evaluates to the array `["a","b"]`, while `"ab".split(/a*/)` evaluates to the array `["","b"]`.)
+
If the *this* object is (or converts to) the empty String, the result depends on whether _separator_ can match the empty String. If it can, the result array contains no elements. Otherwise, the result array contains one element, which is the empty String.
+
If _separator_ is a regular expression that contains capturing parentheses, then each time _separator_ is matched the results (including any *undefined* results) of the capturing parentheses are spliced into the output array. For example,
If _separator_ is *undefined*, then the result array contains just one String, which is the *this* value (converted to a String). If _limit_ is not *undefined*, then the output array is truncated so that it contains no more than _limit_ elements.
+
+
+
The `split` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
Runtime Semantics: SplitMatch ( _S_, _q_, _R_ )
+
The abstract operation SplitMatch takes three parameters, a String _S_, an integer _q_, and a String _R_, and performs the following steps in order to return either *false* or the end index of a match:
+
+ 1. Assert: Type(_R_) is String.
+ 1. Let _r_ be the number of code units in _R_.
+ 1. Let _s_ be the number of code units in _S_.
+ 1. If _q_+_r_ > _s_, return *false*.
+ 1. If there exists an integer _i_ between 0 (inclusive) and _r_ (exclusive) such that the code unit at index _q_+_i_ of _S_ is different from the code unit at index _i_ of _R_, return *false*.
+ 1. Return _q_+_r_.
+
+
+
+
+
+
+
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _isRegExp_ be ? IsRegExp(_searchString_).
+ 1. If _isRegExp_ is *true*, throw a *TypeError* exception.
+ 1. Let _searchStr_ be ? ToString(_searchString_).
+ 1. Let _pos_ be ? ToInteger(_position_). (If _position_ is *undefined*, this step produces the value 0.)
+ 1. Let _len_ be the number of elements in _S_.
+ 1. Let _start_ be min(max(_pos_, 0), _len_).
+ 1. Let _searchLength_ be the number of elements in _searchStr_.
+ 1. If _searchLength_+_start_ is greater than _len_, return *false*.
+ 1. If the sequence of elements of _S_ starting at _start_ of length _searchLength_ is the same as the full element sequence of _searchStr_, return *true*.
+ 1. Otherwise, return *false*.
+
+
The `length` property of the `startsWith` method is 1.
+
+
This method returns *true* if the sequence of elements of _searchString_ converted to a String is the same as the corresponding elements of this object (converted to a String) starting at index _position_. Otherwise returns *false*.
+
+
+
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
+
+
+
The `startsWith` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.substring ( _start_, _end_ )
+
The `substring` method takes two arguments, _start_ and _end_, and returns a substring of the result of converting this object to a String, starting from index _start_ and running to, but not including, index _end_ of the String (or through the end of the String if _end_ is *undefined*). The result is a String value, not a String object.
+
If either argument is *NaN* or negative, it is replaced with zero; if either argument is larger than the length of the String, it is replaced with the length of the String.
+
If _start_ is larger than _end_, they are swapped.
+
The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _len_ be the number of elements in _S_.
+ 1. Let _intStart_ be ? ToInteger(_start_).
+ 1. If _end_ is *undefined*, let _intEnd_ be _len_; else let _intEnd_ be ? ToInteger(_end_).
+ 1. Let _finalStart_ be min(max(_intStart_, 0), _len_).
+ 1. Let _finalEnd_ be min(max(_intEnd_, 0), _len_).
+ 1. Let _from_ be min(_finalStart_, _finalEnd_).
+ 1. Let _to_ be max(_finalStart_, _finalEnd_).
+ 1. Return a String whose length is _to_ - _from_, containing code units from _S_, namely the code units with indices _from_ through _to_ -1, in ascending order.
+
+
+
The `substring` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `toLocaleLowerCase` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleLowerCase` method is used.
+
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in .
+
This function works exactly the same as `toLowerCase` except that its result is intended to yield the correct result for the host environment's current locale, rather than a locale-independent result. There will only be a difference in the few cases (such as Turkish) where the rules for that language conflict with the regular Unicode case mappings.
+
The `length` property of the `toLocaleLowerCase` method is 0.
+
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
+
The `toLocaleLowerCase` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `toLocaleUpperCase` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleUpperCase` method is used.
+
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in .
+
This function works exactly the same as `toUpperCase` except that its result is intended to yield the correct result for the host environment's current locale, rather than a locale-independent result. There will only be a difference in the few cases (such as Turkish) where the rules for that language conflict with the regular Unicode case mappings.
+
The `length` property of the `toLocaleUpperCase` method is 0.
+
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
+
The `toLocaleUpperCase` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.toLowerCase ( )
+
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in . The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _cpList_ be a List containing in order the code points as defined in of _S_, starting at the first element of _S_.
+ 1. For each code point _c_ in _cpList_, if the Unicode Character Database provides a language insensitive lower case equivalent of _c_ then replace _c_ in _cpList_ with that equivalent code point(s).
+ 1. Let _cuList_ be a new List.
+ 1. For each code point _c_ in _cpList_, in order, append to _cuList_ the elements of the UTF16Encoding () of _c_.
+ 1. Let _L_ be a String whose elements are, in order, the elements of _cuList_ .
+ 1. Return _L_.
+
+
The result must be derived according to the locale-insensitive case mappings in the Unicode Character Database (this explicitly includes not only the UnicodeData.txt file, but also all locale-insensitive mappings in the SpecialCasings.txt file that accompanies it).
+
+
The case mapping of some code points may produce multiple code points . In this case the result String may not be the same length as the source String. Because both `toUpperCase` and `toLowerCase` have context-sensitive behaviour, the functions are not symmetrical. In other words, `s.toUpperCase().toLowerCase()` is not necessarily equal to `s.toLowerCase()`.
+
+
+
The `toLowerCase` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.toString ( )
+
When the `toString` method is called, the following steps are taken:
+
+ 1. Let _s_ be thisStringValue(*this* value).
+ 1. Return _s_.
+
+
+
For a String object, the `toString` method happens to return the same thing as the `valueOf` method.
+
+
+
+
+
+
String.prototype.toUpperCase ( )
+
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in .
+
This function behaves in exactly the same way as `String.prototype.toLowerCase`, except that code points are mapped to their _uppercase_ equivalents as specified in the Unicode Character Database.
+
+
The `toUpperCase` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.trim ( )
+
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in .
+
The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _T_ be a String value that is a copy of _S_ with both leading and trailing white space removed. The definition of white space is the union of |WhiteSpace| and |LineTerminator|. When determining whether a Unicode code point is in Unicode general category “Zs”, code unit sequences are interpreted as UTF-16 encoded code point sequences as specified in .
+ 1. Return _T_.
+
+
+
The `trim` function is intentionally generic; it does not require that its *this* value be a String object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.valueOf ( )
+
When the `valueOf` method is called, the following steps are taken:
+
+ 1. Let _s_ be thisStringValue(*this* value).
+ 1. Return _s_.
+
+
+
+
+
+
String.prototype [ @@iterator ]( )
+
When the @@iterator method is called it returns an Iterator object () that iterates over the code points of a String value, returning each code point as a String value. The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Return CreateStringIterator(_S_).
+
+
The value of the `name` property of this function is `"[Symbol.iterator]"`.
+
+
+
+
+
+
Properties of String Instances
+
String instances are String exotic objects and have the internal methods specified for such objects. String instances inherit properties from the String prototype object. String instances also have a [[StringData]] internal slot.
+
String instances have a `length` property, and a set of enumerable properties with integer indexed names.
+
+
+
+
length
+
The number of elements in the String value represented by this String object.
+
Once a String object is initialized, this property is unchanging. It has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
String Iterator Objects
+
An String Iterator is an object, that represents a specific iteration over some specific String instance object. There is not a named constructor for String Iterator objects. Instead, String iterator objects are created by calling certain methods of String instance objects.
+
+
+
+
CreateStringIterator Abstract Operation
+
Several methods of String objects return Iterator objects. The abstract operation CreateStringIterator with argument _string_ is used to create such iterator objects. It performs the following steps:
+
+ 1. Assert: Type(_string_) is String.
+ 1. Let _iterator_ be ObjectCreate(%StringIteratorPrototype%, « [[IteratedString]], [[StringIteratorNextIndex]] »).
+ 1. Set _iterator_'s [[IteratedString]] internal slot to _string_.
+ 1. Set _iterator_'s [[StringIteratorNextIndex]] internal slot to 0.
+ 1. Return _iterator_.
+
+
+
+
+
+
The %StringIteratorPrototype% Object
+
All String Iterator Objects inherit properties from the %StringIteratorPrototype% intrinsic object. The %StringIteratorPrototype% object is an ordinary object and its [[Prototype]] internal slot is the %IteratorPrototype% intrinsic object (). In addition, %StringIteratorPrototype% has the following properties:
+
+
+
+
%StringIteratorPrototype%.next ( )
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have all of the internal slots of an String Iterator Instance (), throw a *TypeError* exception.
+ 1. Let _s_ be the value of the [[IteratedString]] internal slot of _O_.
+ 1. If _s_ is *undefined*, return CreateIterResultObject(*undefined*, *true*).
+ 1. Let _position_ be the value of the [[StringIteratorNextIndex]] internal slot of _O_.
+ 1. Let _len_ be the number of elements in _s_.
+ 1. If _position_ ≥ _len_, then
+ 1. Set the value of the [[IteratedString]] internal slot of _O_ to *undefined*.
+ 1. Return CreateIterResultObject(*undefined*, *true*).
+ 1. Let _first_ be the code unit value at index _position_ in _s_.
+ 1. If _first_ < 0xD800 or _first_ > 0xDBFF or _position_+1 = _len_, let _resultString_ be the string consisting of the single code unit _first_.
+ 1. Else,
+ 1. Let _second_ be the code unit value at index _position_+1 in the String _S_.
+ 1. If _second_ < 0xDC00 or _second_ > 0xDFFF, let _resultString_ be the string consisting of the single code unit _first_.
+ 1. Else, let _resultString_ be the string consisting of the code unit _first_ followed by the code unit _second_.
+ 1. Let _resultSize_ be the number of code units in _resultString_.
+ 1. Set the value of the [[StringIteratorNextIndex]] internal slot of _O_ to _position_+ _resultSize_.
+ 1. Return CreateIterResultObject(_resultString_, *false*).
+
+
+
+
+
+
%StringIteratorPrototype% [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"String Iterator"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of String Iterator Instances
+
String Iterator instances are ordinary objects that inherit properties from the %StringIteratorPrototype% intrinsic object. String Iterator instances are initially created with the internal slots listed in .
+
+
+
+
+
+ Internal Slot
+
+
+ Description
+
+
+
+
+ [[IteratedString]]
+
+
+ The String value whose elements are being iterated.
+
+
+
+
+ [[StringIteratorNextIndex]]
+
+
+ The integer index of the next string index to be examined by this iteration.
+
+
+
+
+
+
+
+
+
+
+
+
RegExp (_Regular_ _Expression_) Objects
+
A RegExp object contains a regular expression and the associated flags.
+
+
The form and functionality of regular expressions is modelled after the regular expression facility in the Perl 5 programming language.
+
+
+
+
+
Patterns
+
The `RegExp` constructor applies the following grammar to the input pattern String. An error occurs if the grammar cannot interpret the String as an expansion of |Pattern|.
Each `\\u` |TrailSurrogate| for which the choice of associated `u` |LeadSurrogate| is ambiguous shall be associated with the nearest possible `u` |LeadSurrogate| that would otherwise have no corresponding `\\u` |TrailSurrogate|.
+
+ LeadSurrogate ::
+ Hex4Digits [match only if the SV of Hex4Digits is in the inclusive range 0xD800 to 0xDBFF]
+
+ TrailSurrogate ::
+ Hex4Digits [match only if the SV of Hex4Digits is in the inclusive range 0xDC00 to 0xDFFF]
+
+ NonSurrogate ::
+ Hex4Digits [match only if the SV of Hex4Digits is not in the inclusive range 0xD800 to 0xDFFF]
+
+ IdentityEscape[U] ::
+ [+U] SyntaxCharacter
+ [+U] `/`
+ [~U] SourceCharacter but not UnicodeIDContinue
+
+ DecimalEscape ::
+ DecimalIntegerLiteral [lookahead <! DecimalDigit]
+
+ CharacterClassEscape :: one of
+ `d` `D` `s` `S` `w` `W`
+
+ CharacterClass[U] ::
+ `[` [lookahead <! {`^`}] ClassRanges[?U] `]`
+ `[` `^` ClassRanges[?U] `]`
+
+ ClassRanges[U] ::
+ [empty]
+ NonemptyClassRanges[?U]
+
+ NonemptyClassRanges[U] ::
+ ClassAtom[?U]
+ ClassAtom[?U] NonemptyClassRangesNoDash[?U]
+ ClassAtom[?U] `-` ClassAtom[?U] ClassRanges[?U]
+
+ NonemptyClassRangesNoDash[U] ::
+ ClassAtom[?U]
+ ClassAtomNoDash[?U] NonemptyClassRangesNoDash[?U]
+ ClassAtomNoDash[?U] `-` ClassAtom[?U] ClassRanges[?U]
+
+ ClassAtom[U] ::
+ `-`
+ ClassAtomNoDash[?U]
+
+ ClassAtomNoDash[U] ::
+ SourceCharacter but not one of `\` or `]` or `-`
+ `\` ClassEscape[?U]
+
+ ClassEscape[U] ::
+ DecimalEscape
+ `b`
+ [+U] `-`
+ CharacterEscape[?U]
+ CharacterClassEscape
+
+
+
+
+
+ It is a Syntax Error if the MV of |HexDigits| > 1114111.
+
+
+
+
+
+
+
+
Pattern Semantics
+
A regular expression pattern is converted into an internal procedure using the process described below. An implementation is encouraged to use more efficient algorithms than the ones listed below, as long as the results are the same. The internal procedure is used as the value of a RegExp object's [[RegExpMatcher]] internal slot.
+
A |Pattern| is either a BMP pattern or a Unicode pattern depending upon whether or not its associated flags contain a `"u"`. A BMP pattern matches against a String interpreted as consisting of a sequence of 16-bit values that are Unicode code points in the range of the Basic Multilingual Plane. A Unicode pattern matches against a String interpreted as consisting of Unicode code points encoded using UTF-16. In the context of describing the behaviour of a BMP pattern “character” means a single 16-bit Unicode BMP code point. In the context of describing the behaviour of a Unicode pattern “character” means a UTF-16 encoded code point (). In either context, “character value” means the numeric value of the corresponding non-encoded code point.
+
The syntax and semantics of |Pattern| is defined as if the source code for the |Pattern| was a List of |SourceCharacter| values where each |SourceCharacter| corresponds to a Unicode code point. If a BMP pattern contains a non-BMP |SourceCharacter| the entire pattern is encoded using UTF-16 and the individual code units of that encoding are used as the elements of the List.
+
+
For example, consider a pattern expressed in source text as the single non-BMP character U+1D11E (MUSICAL SYMBOL G CLEF). Interpreted as a Unicode pattern, it would be a single element (character) List consisting of the single code point 0x1D11E. However, interpreted as a BMP pattern, it is first UTF-16 encoded to produce a two element List consisting of the code units 0xD834 and 0xDD1E.
+
Patterns are passed to the RegExp constructor as ECMAScript String values in which non-BMP characters are UTF-16 encoded. For example, the single character MUSICAL SYMBOL G CLEF pattern, expressed as a String value, is a String of length 2 whose elements were the code units 0xD834 and 0xDD1E. So no further translation of the string would be necessary to process it as a BMP pattern consisting of two pattern characters. However, to process it as a Unicode pattern UTF16Decode (see ) must be used in producing a List consisting of a single pattern character, the code point U+1D11E.
+
An implementation may not actually perform such translations to or from UTF-16, but the semantics of this specification requires that the result of pattern matching be as if such translations were performed.
+
+
+
+
+
Notation
+
The descriptions below use the following variables:
+
+
+ _Input_ is a List consisting of all of the characters, in order, of the String being matched by the regular expression pattern. Each character is either a code unit or a code point, depending upon the kind of pattern involved. The notation _Input_[_n_] means the _n_th character of _Input_, where _n_ can range between 0 (inclusive) and _InputLength_ (exclusive).
+
+
+ _InputLength_ is the number of characters in _Input_.
+
+
+ _NcapturingParens_ is the total number of left capturing parentheses (i.e. the total number of times the Atom :: `(` Disjunction `)` production is expanded) in the pattern. A left capturing parenthesis is any `(` pattern character that is matched by the `(` terminal of the Atom :: `(` Disjunction `)` production.
+
+
+ _IgnoreCase_ is *true* if the RegExp object's [[OriginalFlags]] internal slot contains `"i"` and otherwise is *false*.
+
+
+ _Multiline_ is *true* if the RegExp object's [[OriginalFlags]] internal slot contains `"m"` and otherwise is *false*.
+
+
+ _Unicode_ is *true* if the RegExp object's [[OriginalFlags]] internal slot contains `"u"` and otherwise is *false*.
+
+
+
Furthermore, the descriptions below use the following internal data structures:
+
+
+ A CharSet is a mathematical set of characters, either code units or code points depending up the state of the _Unicode_ flag. “All characters” means either all code unit values or all code point values also depending upon the state if _Unicode_.
+
+
+ A State is an ordered pair (_endIndex_, _captures_) where _endIndex_ is an integer and _captures_ is a List of _NcapturingParens_ values. States are used to represent partial match states in the regular expression matching algorithms. The _endIndex_ is one plus the index of the last input character matched so far by the pattern, while _captures_ holds the results of capturing parentheses. The _n_th element of _captures_ is either a List that represents the value obtained by the _n_th set of capturing parentheses or *undefined* if the _n_th set of capturing parentheses hasn't been reached yet. Due to backtracking, many States may be in use at any time during the matching process.
+
+
+ A MatchResult is either a State or the special token ~failure~ that indicates that the match failed.
+
+
+ A Continuation procedure is an internal closure (i.e. an internal procedure with some arguments already bound to values) that takes one State argument and returns a MatchResult result. If an internal closure references variables which are bound in the function that creates the closure, the closure uses the values that these variables had at the time the closure was created. The Continuation attempts to match the remaining portion (specified by the closure's already-bound arguments) of the pattern against _Input_, starting at the intermediate state given by its State argument. If the match succeeds, the Continuation returns the final State that it reached; if the match fails, the Continuation returns ~failure~.
+
+
+ A Matcher procedure is an internal closure that takes two arguments — a State and a Continuation — and returns a MatchResult result. A Matcher attempts to match a middle subpattern (specified by the closure's already-bound arguments) of the pattern against _Input_, starting at the intermediate state given by its State argument. The Continuation argument should be a closure that matches the rest of the pattern. After matching the subpattern of a pattern to obtain a new State, the Matcher then calls Continuation on that new State to test if the rest of the pattern can match as well. If it can, the Matcher returns the State returned by Continuation; if not, the Matcher may try different choices at its choice points, repeatedly calling Continuation until it either succeeds or all possibilities have been exhausted.
+
+
+ An AssertionTester procedure is an internal closure that takes a State argument and returns a Boolean result. The assertion tester tests a specific condition (specified by the closure's already-bound arguments) against the current place in _Input_ and returns *true* if the condition matched or *false* if not.
+
+
+ An EscapeValue is either a character or an integer. An EscapeValue is used to denote the interpretation of a |DecimalEscape| escape sequence: a character _ch_ means that the escape sequence is interpreted as the character _ch_, while an integer _n_ means that the escape sequence is interpreted as a backreference to the _n_th set of capturing parentheses.
+
+
+
+
+
+
+
Pattern
+
The production Pattern :: Disjunction evaluates as follows:
+
+ 1. Evaluate |Disjunction| to obtain a Matcher _m_.
+ 1. Return an internal closure that takes two arguments, a String _str_ and an integer _index_, and performs the following steps:
+ 1. Assert: _index_ ≤ the number of elements in _str_.
+ 1. If _Unicode_ is *true*, let _Input_ be a List consisting of the sequence of code points of _str_ interpreted as a UTF-16 encoded () Unicode string. Otherwise, let _Input_ be a List consisting of the sequence of code units that are the elements of _str_. _Input_ will be used throughout the algorithms in . Each element of _Input_ is considered to be a character.
+ 1. Let _InputLength_ be the number of characters contained in _Input_. This variable will be used throughout the algorithms in .
+ 1. Let _listIndex_ be the index into _Input_ of the character that was obtained from element _index_ of _str_.
+ 1. Let _c_ be a Continuation that always returns its State argument as a successful MatchResult.
+ 1. Let _cap_ be a List of _NcapturingParens_ *undefined* values, indexed 1 through _NcapturingParens_.
+ 1. Let _x_ be the State (_listIndex_, _cap_).
+ 1. Call _m_(_x_, _c_) and return its result.
+
+
+
A Pattern evaluates (“compiles”) to an internal procedure value. RegExpBuiltinExec can then apply this procedure to a String and an offset within the String to determine whether the pattern would match starting at exactly that offset within the String, and, if it does match, what the values of the capturing parentheses would be. The algorithms in are designed so that compiling a pattern may throw a *SyntaxError* exception; on the other hand, once the pattern is successfully compiled, applying the resulting internal procedure to find a match in a String cannot throw an exception (except for any host-defined exceptions that can occur anywhere such as out-of-memory).
+
+
+
+
+
+
Disjunction
+
The production Disjunction :: Alternative evaluates by evaluating |Alternative| to obtain a Matcher and returning that Matcher.
+
The production Disjunction :: Alternative `|` Disjunction evaluates as follows:
+
+ 1. Evaluate |Alternative| to obtain a Matcher _m1_.
+ 1. Evaluate |Disjunction| to obtain a Matcher _m2_.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps when evaluated:
+ 1. Call _m1_(_x_, _c_) and let _r_ be its result.
+ 1. If _r_ is not ~failure~, return _r_.
+ 1. Call _m2_(_x_, _c_) and return its result.
+
+
+
The `|` regular expression operator separates two alternatives. The pattern first tries to match the left |Alternative| (followed by the sequel of the regular expression); if it fails, it tries to match the right |Disjunction| (followed by the sequel of the regular expression). If the left |Alternative|, the right |Disjunction|, and the sequel all have choice points, all choices in the sequel are tried before moving on to the next choice in the left |Alternative|. If choices in the left |Alternative| are exhausted, the right |Disjunction| is tried instead of the left |Alternative|. Any capturing parentheses inside a portion of the pattern skipped by `|` produce *undefined* values instead of Strings. Thus, for example,
+
/a|ab/.exec("abc")
+
returns the result `"a"` and not `"ab"`. Moreover,
The production Alternative :: [empty] evaluates by returning a Matcher that takes two arguments, a State _x_ and a Continuation _c_, and returns the result of calling _c_(_x_).
+
The production Alternative :: Alternative Term evaluates as follows:
+
+ 1. Evaluate |Alternative| to obtain a Matcher _m1_.
+ 1. Evaluate |Term| to obtain a Matcher _m2_.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps when evaluated:
+ 1. Create a Continuation _d_ that takes a State argument _y_ and returns the result of calling _m2_(_y_, _c_).
+ 1. Call _m1_(_x_, _d_) and return its result.
+
+
+
Consecutive |Term|s try to simultaneously match consecutive portions of _Input_. If the left |Alternative|, the right |Term|, and the sequel of the regular expression all have choice points, all choices in the sequel are tried before moving on to the next choice in the right |Term|, and all choices in the right |Term| are tried before moving on to the next choice in the left |Alternative|.
+
+
+
+
+
+
Term
+
The production Term :: Assertion evaluates by returning an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps when evaluated:
+
+ 1. Evaluate |Assertion| to obtain an AssertionTester _t_.
+ 1. Call _t_(_x_) and let _r_ be the resulting Boolean value.
+ 1. If _r_ is *false*, return ~failure~.
+ 1. Call _c_(_x_) and return its result.
+
+
The production Term :: Atom evaluates as follows:
+
+ 1. Return the Matcher that is the result of evaluating |Atom|.
+
+
The production Term :: Atom Quantifier evaluates as follows:
+
+ 1. Evaluate |Atom| to obtain a Matcher _m_.
+ 1. Evaluate |Quantifier| to obtain the three results: an integer _min_, an integer (or ∞) _max_, and Boolean _greedy_.
+ 1. If _max_ is finite and less than _min_, throw a *SyntaxError* exception.
+ 1. Let _parenIndex_ be the number of left capturing parentheses in the entire regular expression that occur to the left of this production expansion's |Term|. This is the total number of times the Atom :: `(` Disjunction `)` production is expanded prior to this production's |Term| plus the total number of Atom :: `(` Disjunction `)` productions enclosing this |Term|.
+ 1. Let _parenCount_ be the number of left capturing parentheses in the expansion of this production's |Atom|. This is the total number of Atom :: `(` Disjunction `)` productions enclosed by this production's |Atom|.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps when evaluated:
+ 1. Call RepeatMatcher(_m_, _min_, _max_, _greedy_, _x_, _c_, _parenIndex_, _parenCount_) and return its result.
+
+
+
+
+
The abstract operation RepeatMatcher takes eight parameters, a Matcher _m_, an integer _min_, an integer (or ∞) _max_, a Boolean _greedy_, a State _x_, a Continuation _c_, an integer _parenIndex_, and an integer _parenCount_, and performs the following steps:
+
+ 1. If _max_ is zero, return _c_(_x_).
+ 1. Create an internal Continuation closure _d_ that takes one State argument _y_ and performs the following steps when evaluated:
+ 1. If _min_ is zero and _y_'s _endIndex_ is equal to _x_'s _endIndex_, return ~failure~.
+ 1. If _min_ is zero, let _min2_ be zero; otherwise let _min2_ be _min_-1.
+ 1. If _max_ is ∞, let _max2_ be ∞; otherwise let _max2_ be _max_-1.
+ 1. Call RepeatMatcher(_m_, _min2_, _max2_, _greedy_, _y_, _c_, _parenIndex_, _parenCount_) and return its result.
+ 1. Let _cap_ be a fresh copy of _x_'s _captures_ List.
+ 1. For every integer _k_ that satisfies _parenIndex_ < _k_ and _k_ ≤ _parenIndex_+_parenCount_, set _cap_[_k_] to *undefined*.
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. Let _xr_ be the State (_e_, _cap_).
+ 1. If _min_ is not zero, return _m_(_xr_, _d_).
+ 1. If _greedy_ is *false*, then
+ 1. Call _c_(_x_) and let _z_ be its result.
+ 1. If _z_ is not ~failure~, return _z_.
+ 1. Call _m_(_xr_, _d_) and return its result.
+ 1. Call _m_(_xr_, _d_) and let _z_ be its result.
+ 1. If _z_ is not ~failure~, return _z_.
+ 1. Call _c_(_x_) and return its result.
+
+
+
An |Atom| followed by a |Quantifier| is repeated the number of times specified by the |Quantifier|. A |Quantifier| can be non-greedy, in which case the |Atom| pattern is repeated as few times as possible while still matching the sequel, or it can be greedy, in which case the |Atom| pattern is repeated as many times as possible while still matching the sequel. The |Atom| pattern is repeated rather than the input character sequence that it matches, so different repetitions of the |Atom| can match different input substrings.
+
+
+
If the |Atom| and the sequel of the regular expression all have choice points, the |Atom| is first matched as many (or as few, if non-greedy) times as possible. All choices in the sequel are tried before moving on to the next choice in the last repetition of |Atom|. All choices in the last (nth) repetition of |Atom| are tried before moving on to the next choice in the next-to-last (n-1)st repetition of |Atom|; at which point it may turn out that more or fewer repetitions of |Atom| are now possible; these are exhausted (again, starting with either as few or as many as possible) before moving on to the next choice in the (n-1)st repetition of |Atom| and so on.
+
Compare
+
/a[a-z]{2,4}/.exec("abcdefghi")
+
which returns `"abcde"` with
+
/a[a-z]{2,4}?/.exec("abcdefghi")
+
which returns `"abc"`.
+
Consider also
+
/(aa|aabaac|ba|b|c)*/.exec("aabaac")
+
which, by the choice point ordering above, returns the array
+
["aaba", "ba"]
+
and not any of:
+
+["aabaac", "aabaac"]
+["aabaac", "c"]
+
+
The above ordering of choice points can be used to write a regular expression that calculates the greatest common divisor of two numbers (represented in unary notation). The following example calculates the gcd of 10 and 15:
which returns the gcd in unary notation `"aaaaa"`.
+
+
+
Step 5 of the RepeatMatcher clears |Atom|'s captures each time |Atom| is repeated. We can see its behaviour in the regular expression
+
/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")
+
which returns the array
+
["zaacbbbcac", "z", "ac", "a", undefined, "c"]
+
and not
+
["zaacbbbcac", "z", "ac", "a", "bbb", "c"]
+
because each iteration of the outermost `*` clears all captured Strings contained in the quantified |Atom|, which in this case includes capture Strings numbered 2, 3, 4, and 5.
+
+
+
Step 1 of the RepeatMatcher's _d_ closure states that, once the minimum number of repetitions has been satisfied, any more expansions of |Atom| that match the empty character sequence are not considered for further repetitions. This prevents the regular expression engine from falling into an infinite loop on patterns such as:
+
/(a*)*/.exec("b")
+
or the slightly more complicated:
+
/(a*)b\1+/.exec("baaaac")
+
which returns the array
+
["b", ""]
+
+
+
+
+
+
+
Assertion
+
The production Assertion :: `^` evaluates by returning an internal AssertionTester closure that takes a State argument _x_ and performs the following steps when evaluated:
+
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. If _e_ is zero, return *true*.
+ 1. If _Multiline_ is *false*, return *false*.
+ 1. If the character _Input_[_e_-1] is one of |LineTerminator|, return *true*.
+ 1. Return *false*.
+
+
+
Even when the `y` flag is used with a pattern, `^` always matches only at the beginning of _Input_, or (if _Multiline_ is *true*) at the beginning of a line.
+
+
The production Assertion :: `$` evaluates by returning an internal AssertionTester closure that takes a State argument _x_ and performs the following steps when evaluated:
+
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. If _e_ is equal to _InputLength_, return *true*.
+ 1. If _Multiline_ is *false*, return *false*.
+ 1. If the character _Input_[_e_] is one of |LineTerminator|, return *true*.
+ 1. Return *false*.
+
+
The production Assertion :: `\` `b` evaluates by returning an internal AssertionTester closure that takes a State argument _x_ and performs the following steps when evaluated:
+
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. Call IsWordChar(_e_-1) and let _a_ be the Boolean result.
+ 1. Call IsWordChar(_e_) and let _b_ be the Boolean result.
+ 1. If _a_ is *true* and _b_ is *false*, return *true*.
+ 1. If _a_ is *false* and _b_ is *true*, return *true*.
+ 1. Return *false*.
+
+
The production Assertion :: `\` `B` evaluates by returning an internal AssertionTester closure that takes a State argument _x_ and performs the following steps when evaluated:
+
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. Call IsWordChar(_e_-1) and let _a_ be the Boolean result.
+ 1. Call IsWordChar(_e_) and let _b_ be the Boolean result.
+ 1. If _a_ is *true* and _b_ is *false*, return *false*.
+ 1. If _a_ is *false* and _b_ is *true*, return *false*.
+ 1. Return *true*.
+
+
The production Assertion :: `(` `?` `=` Disjunction `)` evaluates as follows:
+
+ 1. Evaluate |Disjunction| to obtain a Matcher _m_.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps:
+ 1. Let _d_ be a Continuation that always returns its State argument as a successful MatchResult.
+ 1. Call _m_(_x_, _d_) and let _r_ be its result.
+ 1. If _r_ is ~failure~, return ~failure~.
+ 1. Let _y_ be _r_'s State.
+ 1. Let _cap_ be _y_'s _captures_ List.
+ 1. Let _xe_ be _x_'s _endIndex_.
+ 1. Let _z_ be the State (_xe_, _cap_).
+ 1. Call _c_(_z_) and return its result.
+
+
The production Assertion :: `(` `?` `!` Disjunction `)` evaluates as follows:
+
+ 1. Evaluate |Disjunction| to obtain a Matcher _m_.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps:
+ 1. Let _d_ be a Continuation that always returns its State argument as a successful MatchResult.
+ 1. Call _m_(_x_, _d_) and let _r_ be its result.
+ 1. If _r_ is not ~failure~, return ~failure~.
+ 1. Call _c_(_x_) and return its result.
+
+
+
+
+
Runtime Semantics: IsWordChar Abstract Operation
+
The abstract operation IsWordChar takes an integer parameter _e_ and performs the following steps:
+
+ 1. If _e_ is -1 or _e_ is _InputLength_, return *false*.
+ 1. Let _c_ be the character _Input_[_e_].
+ 1. If _c_ is one of the sixty-three characters below, return *true*.
+
+
+
+
+
+ `a`
+
+
+ `b`
+
+
+ `c`
+
+
+ `d`
+
+
+ `e`
+
+
+ `f`
+
+
+ `g`
+
+
+ `h`
+
+
+ `i`
+
+
+ `j`
+
+
+ `k`
+
+
+ `l`
+
+
+ `m`
+
+
+ `n`
+
+
+ `o`
+
+
+ `p`
+
+
+ `q`
+
+
+ `r`
+
+
+ `s`
+
+
+ `t`
+
+
+ `u`
+
+
+ `v`
+
+
+ `w`
+
+
+ `x`
+
+
+ `y`
+
+
+ `z`
+
+
+
+
+ `A`
+
+
+ `B`
+
+
+ `C`
+
+
+ `D`
+
+
+ `E`
+
+
+ `F`
+
+
+ `G`
+
+
+ `H`
+
+
+ `I`
+
+
+ `J`
+
+
+ `K`
+
+
+ `L`
+
+
+ `M`
+
+
+ `N`
+
+
+ `O`
+
+
+ `P`
+
+
+ `Q`
+
+
+ `R`
+
+
+ `S`
+
+
+ `T`
+
+
+ `U`
+
+
+ `V`
+
+
+ `W`
+
+
+ `X`
+
+
+ `Y`
+
+
+ `Z`
+
+
+
+
+ `0`
+
+
+ `1`
+
+
+ `2`
+
+
+ `3`
+
+
+ `4`
+
+
+ `5`
+
+
+ `6`
+
+
+ `7`
+
+
+ `8`
+
+
+ `9`
+
+
+ `_`
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1. Return *false*.
+
+
+
+
+
+
+
Quantifier
+
The production Quantifier :: QuantifierPrefix evaluates as follows:
+
+ 1. Evaluate |QuantifierPrefix| to obtain the two results: an integer _min_ and an integer (or ∞) _max_.
+ 1. Return the three results _min_, _max_, and *true*.
+
+
The production Quantifier :: QuantifierPrefix `?` evaluates as follows:
+
+ 1. Evaluate |QuantifierPrefix| to obtain the two results: an integer _min_ and an integer (or ∞) _max_.
+ 1. Return the three results _min_, _max_, and *false*.
+
+
The production QuantifierPrefix :: `*` evaluates as follows:
+
+ 1. Return the two results 0 and ∞.
+
+
The production QuantifierPrefix :: `+` evaluates as follows:
+
+ 1. Return the two results 1 and ∞.
+
+
The production QuantifierPrefix :: `?` evaluates as follows:
+
+ 1. Return the two results 0 and 1.
+
+
The production QuantifierPrefix :: `{` DecimalDigits `}` evaluates as follows:
+
+ 1. Let _i_ be the MV of |DecimalDigits| (see ).
+ 1. Return the two results _i_ and _i_.
+
+
The production QuantifierPrefix :: `{` DecimalDigits `,` `}` evaluates as follows:
+
+ 1. Let _i_ be the MV of |DecimalDigits|.
+ 1. Return the two results _i_ and ∞.
+
+
The production QuantifierPrefix :: `{` DecimalDigits `,` DecimalDigits `}` evaluates as follows:
+
+ 1. Let _i_ be the MV of the first |DecimalDigits|.
+ 1. Let _j_ be the MV of the second |DecimalDigits|.
+ 1. Return the two results _i_ and _j_.
+
+
+
+
+
+
Atom
+
The production Atom :: PatternCharacter evaluates as follows:
+
+ 1. Let _ch_ be the character matched by |PatternCharacter|.
+ 1. Let _A_ be a one-element CharSet containing the character _ch_.
+ 1. Call CharacterSetMatcher(_A_, *false*) and return its Matcher result.
+
+
The production Atom :: `.` evaluates as follows:
+
+ 1. Let _A_ be the set of all characters except |LineTerminator|.
+ 1. Call CharacterSetMatcher(_A_, *false*) and return its Matcher result.
+
+
The production Atom :: `\` AtomEscape evaluates as follows:
+
+ 1. Return the Matcher that is the result of evaluating |AtomEscape|.
+
+
The production Atom :: CharacterClass evaluates as follows:
+
+ 1. Evaluate |CharacterClass| to obtain a CharSet _A_ and a Boolean _invert_.
+ 1. Call CharacterSetMatcher(_A_, _invert_) and return its Matcher result.
+
+
The production Atom :: `(` Disjunction `)` evaluates as follows:
+
+ 1. Evaluate |Disjunction| to obtain a Matcher _m_.
+ 1. Let _parenIndex_ be the number of left capturing parentheses in the entire regular expression that occur to the left of this production expansion's initial left parenthesis. This is the total number of times the Atom :: `(` Disjunction `)` production is expanded prior to this production's |Atom| plus the total number of Atom :: `(` Disjunction `)` productions enclosing this |Atom|.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps:
+ 1. Create an internal Continuation closure _d_ that takes one State argument _y_ and performs the following steps:
+ 1. Let _cap_ be a fresh copy of _y_'s _captures_ List.
+ 1. Let _xe_ be _x_'s _endIndex_.
+ 1. Let _ye_ be _y_'s _endIndex_.
+ 1. Let _s_ be a fresh List whose characters are the characters of _Input_ at indices _xe_ (inclusive) through _ye_ (exclusive).
+ 1. Set _cap_[_parenIndex_+1] to _s_.
+ 1. Let _z_ be the State (_ye_, _cap_).
+ 1. Call _c_(_z_) and return its result.
+ 1. Call _m_(_x_, _d_) and return its result.
+
+
The production Atom :: `(` `?` `:` Disjunction `)` evaluates as follows:
+
+ 1. Return the Matcher that is the result of evaluating |Disjunction|.
+
+
+
+
+
The abstract operation CharacterSetMatcher takes two arguments, a CharSet _A_ and a Boolean flag _invert_, and performs the following steps:
+
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps when evaluated:
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. If _e_ is _InputLength_, return ~failure~.
+ 1. Let _ch_ be the character _Input_[_e_].
+ 1. Let _cc_ be Canonicalize(_ch_).
+ 1. If _invert_ is *false*, then
+ 1. If there does not exist a member _a_ of set _A_ such that Canonicalize(_a_) is _cc_, return ~failure~.
+ 1. Else _invert_ is *true*,
+ 1. If there exists a member _a_ of set _A_ such that Canonicalize(_a_) is _cc_, return ~failure~.
+ 1. Let _cap_ be _x_'s _captures_ List.
+ 1. Let _y_ be the State (_e_+1, _cap_).
+ 1. Call _c_(_y_) and return its result.
+
+
+
+
+
+
Runtime Semantics: Canonicalize ( _ch_ )
+
The abstract operation Canonicalize takes a character parameter _ch_ and performs the following steps:
+
+ 1. If _IgnoreCase_ is *false*, return _ch_.
+ 1. If _Unicode_ is *true*, then
+ 1. If the file CaseFolding.txt of the Unicode Character Database provides a simple or common case folding mapping for _ch_, return the result of applying that mapping to _ch_.
+ 1. Else, return _ch_.
+ 1. Else,
+ 1. Assert: _ch_ is a UTF-16 code unit.
+ 1. Let _s_ be the ECMAScript String value consisting of the single code unit _ch_.
+ 1. Let _u_ be the same result produced as if by performing the algorithm for `String.prototype.toUpperCase` using _s_ as the *this* value.
+ 1. Assert: _u_ is a String value.
+ 1. If _u_ does not consist of a single code unit, return _ch_.
+ 1. Let _cu_ be _u_'s single code unit element.
+ 1. If _ch_'s code unit value ≥ 128 and _cu_'s code unit value < 128, return _ch_.
+ 1. Return _cu_.
+
+
+
Parentheses of the form `(` |Disjunction| `)` serve both to group the components of the |Disjunction| pattern together and to save the result of the match. The result can be used either in a backreference (`\\` followed by a nonzero decimal number), referenced in a replace String, or returned as part of an array from the regular expression matching internal procedure. To inhibit the capturing behaviour of parentheses, use the form `(?:` |Disjunction| `)` instead.
+
+
+
The form `(?=` |Disjunction| `)` specifies a zero-width positive lookahead. In order for it to succeed, the pattern inside |Disjunction| must match at the current position, but the current position is not advanced before matching the sequel. If |Disjunction| can match at the current position in several ways, only the first one is tried. Unlike other regular expression operators, there is no backtracking into a `(?=` form (this unusual behaviour is inherited from Perl). This only matters when the |Disjunction| contains capturing parentheses and the sequel of the pattern contains backreferences to those captures.
+
For example,
+
/(?=(a+))/.exec("baaabac")
+
matches the empty String immediately after the first `b` and therefore returns the array:
+
["", "aaa"]
+
To illustrate the lack of backtracking into the lookahead, consider:
+
/(?=(a+))a*b\1/.exec("baaabac")
+
This expression returns
+
["aba", "a"]
+
and not:
+
["aaaba", "a"]
+
+
+
The form `(?!` |Disjunction| `)` specifies a zero-width negative lookahead. In order for it to succeed, the pattern inside |Disjunction| must fail to match at the current position. The current position is not advanced before matching the sequel. |Disjunction| can contain capturing parentheses, but backreferences to them only make sense from within |Disjunction| itself. Backreferences to these capturing parentheses from elsewhere in the pattern always return *undefined* because the negative lookahead must fail for the pattern to succeed. For example,
+
/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")
+
looks for an `a` not immediately followed by some positive number n of `a`'s, a `b`, another n `a`'s (specified by the first `\\2`) and a `c`. The second `\\2` is outside the negative lookahead, so it matches against *undefined* and therefore always succeeds. The whole expression returns the array:
+
["baaabaac", "ba", undefined, "abaac"]
+
+
+
In case-insignificant matches when _Unicode_ is *true*, all characters are implicitly case-folded using the simple mapping provided by the Unicode standard immediately before they are compared. The simple mapping always maps to a single code point, so it does not map, for example, `"ß"` (U+00DF) to `"SS"`. It may however map a code point outside the Basic Latin range to a character within, for example, `"ſ"` (U+017F) to `"s"`. Such characters are not mapped if _Unicode_ is *false*. This prevents Unicode code points such as U+017F and U+212A from matching regular expressions such as `/[a-z]/i`, but they will match `/[a-z]/ui`.
+
+
+
+
+
+
+
AtomEscape
+
The production AtomEscape :: DecimalEscape evaluates as follows:
+
+ 1. Evaluate |DecimalEscape| to obtain an EscapeValue _E_.
+ 1. If _E_ is a character, then
+ 1. Let _ch_ be _E_'s character.
+ 1. Let _A_ be a one-element CharSet containing the character _ch_.
+ 1. Call CharacterSetMatcher(_A_, *false*) and return its Matcher result.
+ 1. Assert: _E_ must be an integer.
+ 1. Let _n_ be that integer.
+ 1. If _n_=0 or _n_>_NcapturingParens_, throw a *SyntaxError* exception.
+ 1. Return an internal Matcher closure that takes two arguments, a State _x_ and a Continuation _c_, and performs the following steps:
+ 1. Let _cap_ be _x_'s _captures_ List.
+ 1. Let _s_ be _cap_[_n_].
+ 1. If _s_ is *undefined*, return _c_(_x_).
+ 1. Let _e_ be _x_'s _endIndex_.
+ 1. Let _len_ be _s_'s length.
+ 1. Let _f_ be _e_+_len_.
+ 1. If _f_>_InputLength_, return ~failure~.
+ 1. If there exists an integer _i_ between 0 (inclusive) and _len_ (exclusive) such that Canonicalize(_s_[_i_]) is not the same character value as Canonicalize(_Input_ [_e_+_i_]), return ~failure~.
+ 1. Let _y_ be the State (_f_, _cap_).
+ 1. Call _c_(_y_) and return its result.
+
+
The production AtomEscape :: CharacterEscape evaluates as follows:
+
+ 1. Evaluate |CharacterEscape| to obtain a character _ch_.
+ 1. Let _A_ be a one-element CharSet containing the character _ch_.
+ 1. Call CharacterSetMatcher(_A_, *false*) and return its Matcher result.
+
+
The production AtomEscape :: CharacterClassEscape evaluates as follows:
+
+ 1. Evaluate |CharacterClassEscape| to obtain a CharSet _A_.
+ 1. Call CharacterSetMatcher(_A_, *false*) and return its Matcher result.
+
+
+
An escape sequence of the form `\\` followed by a nonzero decimal number _n_ matches the result of the _n_th set of capturing parentheses (see 0). It is an error if the regular expression has fewer than _n_ capturing parentheses. If the regular expression has _n_ or more capturing parentheses but the _n_th one is *undefined* because it has not captured anything, then the backreference always succeeds.
+
+
+
+
+
+
CharacterEscape
+
The production CharacterEscape :: ControlEscape evaluates by returning the character according to .
+
+
+
+
+
+ ControlEscape
+
+
+ Character Value
+
+
+ Code Point
+
+
+ Unicode Name
+
+
+ Symbol
+
+
+
+
+ `t`
+
+
+ 9
+
+
+ `U+0009`
+
+
+ CHARACTER TABULATION
+
+
+ <HT>
+
+
+
+
+ `n`
+
+
+ 10
+
+
+ `U+000A`
+
+
+ LINE FEED (LF)
+
+
+ <LF>
+
+
+
+
+ `v`
+
+
+ 11
+
+
+ `U+000B`
+
+
+ LINE TABULATION
+
+
+ <VT>
+
+
+
+
+ `f`
+
+
+ 12
+
+
+ `U+000C`
+
+
+ FORM FEED (FF)
+
+
+ <FF>
+
+
+
+
+ `r`
+
+
+ 13
+
+
+ `U+000D`
+
+
+ CARRIAGE RETURN (CR)
+
+
+ <CR>
+
+
+
+
+
+
The production CharacterEscape :: `c` ControlLetter evaluates as follows:
+
+ 1. Let _ch_ be the character matched by |ControlLetter|.
+ 1. Let _i_ be _ch_'s character value.
+ 1. Let _j_ be the remainder of dividing _i_ by 32.
+ 1. Return the character whose character value is _j_.
+
+
The production CharacterEscape :: HexEscapeSequence evaluates as follows:
+
+ 1. Return the character whose code is the SV of |HexEscapeSequence|.
+
+
The production CharacterEscape :: RegExpUnicodeEscapeSequence evaluates as follows:
+
+ 1. Return the result of evaluating |RegExpUnicodeEscapeSequence|.
+
+
The production CharacterEscape :: IdentityEscape evaluates as follows:
+
+ 1. Return the character matched by |IdentityEscape|.
+
+
The production RegExpUnicodeEscapeSequence :: `u` LeadSurrogate `\u` TrailSurrogate evaluates as follows:
+
+ 1. Let _lead_ be the result of evaluating |LeadSurrogate|.
+ 1. Let _trail_ be the result of evaluating |TrailSurrogate|.
+ 1. Let _cp_ be UTF16Decode(_lead_, _trail_).
+ 1. Return the character whose character value is _cp_.
+
+
The production RegExpUnicodeEscapeSequence :: `u` LeadSurrogate evaluates as follows:
+
+ 1. Return the character whose code is the result of evaluating |LeadSurrogate|.
+
+
The production RegExpUnicodeEscapeSequence :: `u` TrailSurrogate evaluates as follows:
+
+ 1. Return the character whose code is the result of evaluating |TrailSurrogate|.
+
+
The production RegExpUnicodeEscapeSequence :: `u` NonSurrogate evaluates as follows:
+
+ 1. Return the character whose code is the result of evaluating |NonSurrogate|.
+
+
The production RegExpUnicodeEscapeSequence :: `u` Hex4Digits evaluates as follows:
+
+ 1. Return the character whose code is the SV of |Hex4Digits|.
+
+
The production RegExpUnicodeEscapeSequence :: `u{` HexDigits `}` evaluates as follows:
+
+ 1. Return the character whose code is the MV of |HexDigits|.
+
+
The production LeadSurrogate :: Hex4Digits evaluates as follows:
+
+ 1. Return the character whose code is the SV of |Hex4Digits|.
+
+
The production TrailSurrogate :: Hex4Digits evaluates as follows:
+
+ 1. Return the character whose code is the SV of |Hex4Digits|.
+
+
The production NonSurrogate :: Hex4Digits evaluates as follows:
+
+ 1. Return the character whose code is the SV of |Hex4Digits|.
+
+
+
+
+
+
DecimalEscape
+
The production DecimalEscape :: DecimalIntegerLiteral evaluates as follows:
+
+ 1. Let _i_ be the MV of |DecimalIntegerLiteral|.
+ 1. If _i_ is zero, return the EscapeValue consisting of the character U+0000 (NULL).
+ 1. Return the EscapeValue consisting of the integer _i_.
+
+
The definition of “the MV of |DecimalIntegerLiteral|” is in .
+
+
If `\\` is followed by a decimal number _n_ whose first digit is not `0`, then the escape sequence is considered to be a backreference. It is an error if _n_ is greater than the total number of left capturing parentheses in the entire regular expression. `\\0` represents the <NUL> character and cannot be followed by a decimal digit.
+
+
+
+
+
+
CharacterClassEscape
+
The production CharacterClassEscape :: `d` evaluates by returning the ten-element set of characters containing the characters `0` through `9` inclusive.
+
The production CharacterClassEscape :: `D` evaluates by returning the set of all characters not included in the set returned by CharacterClassEscape :: `d` .
+
The production CharacterClassEscape :: `s` evaluates by returning the set of characters containing the characters that are on the right-hand side of the |WhiteSpace| () or |LineTerminator| () productions.
+
The production CharacterClassEscape :: `S` evaluates by returning the set of all characters not included in the set returned by CharacterClassEscape :: `s` .
+
The production CharacterClassEscape :: `w` evaluates by returning the set of characters containing the sixty-three characters:
+
+
+
+
+
+ `a`
+
+
+ `b`
+
+
+ `c`
+
+
+ `d`
+
+
+ `e`
+
+
+ `f`
+
+
+ `g`
+
+
+ `h`
+
+
+ `i`
+
+
+ `j`
+
+
+ `k`
+
+
+ `l`
+
+
+ `m`
+
+
+ `n`
+
+
+ `o`
+
+
+ `p`
+
+
+ `q`
+
+
+ `r`
+
+
+ `s`
+
+
+ `t`
+
+
+ `u`
+
+
+ `v`
+
+
+ `w`
+
+
+ `x`
+
+
+ `y`
+
+
+ `z`
+
+
+
+
+ `A`
+
+
+ `B`
+
+
+ `C`
+
+
+ `D`
+
+
+ `E`
+
+
+ `F`
+
+
+ `G`
+
+
+ `H`
+
+
+ `I`
+
+
+ `J`
+
+
+ `K`
+
+
+ `L`
+
+
+ `M`
+
+
+ `N`
+
+
+ `O`
+
+
+ `P`
+
+
+ `Q`
+
+
+ `R`
+
+
+ `S`
+
+
+ `T`
+
+
+ `U`
+
+
+ `V`
+
+
+ `W`
+
+
+ `X`
+
+
+ `Y`
+
+
+ `Z`
+
+
+
+
+ `0`
+
+
+ `1`
+
+
+ `2`
+
+
+ `3`
+
+
+ `4`
+
+
+ `5`
+
+
+ `6`
+
+
+ `7`
+
+
+ `8`
+
+
+ `9`
+
+
+ `_`
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The production CharacterClassEscape :: `W` evaluates by returning the set of all characters not included in the set returned by CharacterClassEscape :: `w` .
+
+
+
+
+
CharacterClass
+
The production CharacterClass :: `[` ClassRanges `]` evaluates by evaluating |ClassRanges| to obtain a CharSet and returning that CharSet and the Boolean *false*.
+
The production CharacterClass :: `[` `^` ClassRanges `]` evaluates by evaluating |ClassRanges| to obtain a CharSet and returning that CharSet and the Boolean *true*.
+
+
+
+
+
ClassRanges
+
The production ClassRanges :: [empty] evaluates by returning the empty CharSet.
+
The production ClassRanges :: NonemptyClassRanges evaluates by evaluating |NonemptyClassRanges| to obtain a CharSet and returning that CharSet.
+
+
+
+
+
NonemptyClassRanges
+
The production NonemptyClassRanges :: ClassAtom evaluates as follows:
+
+ 1. Return the CharSet that is the result of evaluating |ClassAtom|.
+
+
The production NonemptyClassRanges :: ClassAtom NonemptyClassRangesNoDash evaluates as follows:
+
+ 1. Evaluate |ClassAtom| to obtain a CharSet _A_.
+ 1. Evaluate |NonemptyClassRangesNoDash| to obtain a CharSet _B_.
+ 1. Return the union of CharSets _A_ and _B_.
+
+
The production NonemptyClassRanges :: ClassAtom `-` ClassAtom ClassRanges evaluates as follows:
+
+ 1. Evaluate the first |ClassAtom| to obtain a CharSet _A_.
+ 1. Evaluate the second |ClassAtom| to obtain a CharSet _B_.
+ 1. Evaluate |ClassRanges| to obtain a CharSet _C_.
+ 1. Call CharacterRange(_A_, _B_) and let _D_ be the resulting CharSet.
+ 1. Return the union of CharSets _D_ and _C_.
+
+
+
+
+
The abstract operation CharacterRange takes two CharSet parameters _A_ and _B_ and performs the following steps:
+
+ 1. If _A_ does not contain exactly one character or _B_ does not contain exactly one character, throw a *SyntaxError* exception.
+ 1. Let _a_ be the one character in CharSet _A_.
+ 1. Let _b_ be the one character in CharSet _B_.
+ 1. Let _i_ be the character value of character _a_.
+ 1. Let _j_ be the character value of character _b_.
+ 1. If _i_ > _j_, throw a *SyntaxError* exception.
+ 1. Return the set containing all characters numbered _i_ through _j_, inclusive.
+
+
+
+
+
+
+
NonemptyClassRangesNoDash
+
The production NonemptyClassRangesNoDash :: ClassAtom evaluates as follows:
+
+ 1. Return the CharSet that is the result of evaluating |ClassAtom|.
+
+
The production NonemptyClassRangesNoDash :: ClassAtomNoDash NonemptyClassRangesNoDash evaluates as follows:
+
+ 1. Evaluate |ClassAtomNoDash| to obtain a CharSet _A_.
+ 1. Evaluate |NonemptyClassRangesNoDash| to obtain a CharSet _B_.
+ 1. Return the union of CharSets _A_ and _B_.
+
+
The production NonemptyClassRangesNoDash :: ClassAtomNoDash `-` ClassAtom ClassRanges evaluates as follows:
+
+ 1. Evaluate |ClassAtomNoDash| to obtain a CharSet _A_.
+ 1. Evaluate |ClassAtom| to obtain a CharSet _B_.
+ 1. Evaluate |ClassRanges| to obtain a CharSet _C_.
+ 1. Call CharacterRange(_A_, _B_) and let _D_ be the resulting CharSet.
+ 1. Return the union of CharSets _D_ and _C_.
+
+
+
|ClassRanges| can expand into a single |ClassAtom| and/or ranges of two |ClassAtom| separated by dashes. In the latter case the |ClassRanges| includes all characters between the first |ClassAtom| and the second |ClassAtom|, inclusive; an error occurs if either |ClassAtom| does not represent a single character (for example, if one is \w) or if the first |ClassAtom|'s character value is greater than the second |ClassAtom|'s character value.
+
+
+
Even if the pattern ignores case, the case of the two ends of a range is significant in determining which characters belong to the range. Thus, for example, the pattern `/[E-F]/i` matches only the letters `E`, `F`, `e`, and `f`, while the pattern `/[E-f]/i` matches all upper and lower-case letters in the Unicode Basic Latin block as well as the symbols `[`, `\\`, `]`, `^`, `_`, and `.
+
+
+
A `-` character can be treated literally or it can denote a range. It is treated literally if it is the first or last character of |ClassRanges|, the beginning or end limit of a range specification, or immediately follows a range specification.
+
+
+
+
+
+
ClassAtom
+
The production ClassAtom :: `-` evaluates by returning the CharSet containing the one character `-`.
+
The production ClassAtom :: ClassAtomNoDash evaluates by evaluating |ClassAtomNoDash| to obtain a CharSet and returning that CharSet.
+
+
+
+
+
ClassAtomNoDash
+
The production ClassAtomNoDash :: SourceCharacter but not one of `\` or `]` or `-` evaluates as follows:
+
+ 1. Return the CharSet containing the character matched by |SourceCharacter|.
+
+
The production ClassAtomNoDash :: `\` ClassEscape evaluates as follows:
+
+ 1. Return the CharSet that is the result of evaluating |ClassEscape|.
+
+
+
+
+
+
ClassEscape
+
The production ClassEscape :: DecimalEscape evaluates as follows:
+
+ 1. Evaluate |DecimalEscape| to obtain an EscapeValue _E_.
+ 1. If _E_ is not a character, throw a *SyntaxError* exception.
+ 1. Let _ch_ be _E_'s character.
+ 1. Return the one-element CharSet containing the character _ch_.
+
+
The production ClassEscape :: `b` evaluates as follows:
+
+ 1. Return the CharSet containing the single character <BS> U+0008 (BACKSPACE).
+
+
The production ClassEscape :: `-` evaluates as follows:
+
+ 1. Return the CharSet containing the single character - U+002D (HYPEN-MINUS).
+
+
The production ClassEscape :: CharacterEscape evaluates as follows:
+
+ 1. Return the CharSet containing the single character that is the result of evaluating |CharacterEscape|.
+
+
The production ClassEscape :: CharacterClassEscape evaluates as follows:
+
+ 1. Return the CharSet that is the result of evaluating |CharacterClassEscape|.
+
+
+
A |ClassAtom| can use any of the escape sequences that are allowed in the rest of the regular expression except for `\\b`, `\\B`, and backreferences. Inside a |CharacterClass|, `\\b` means the backspace character, while `\\B` and backreferences raise errors. Using a backreference inside a |ClassAtom| causes an error.
+
+
+
+
+
+
+
The RegExp Constructor
+
The RegExp constructor is the %RegExp% intrinsic object and the initial value of the `RegExp` property of the global object. When `RegExp` is called as a function rather than as a constructor, it creates and initializes a new RegExp object. Thus the function call `RegExp(…)` is equivalent to the object creation expression `new RegExp(…)` with the same arguments.
+
The `RegExp` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `RegExp` behaviour must include a `super` call to the `RegExp` constructor to create and initialize subclass instances with the necessary internal slots.
+
+
+
+
RegExp ( _pattern_, _flags_ )
+
The following steps are taken:
+
+ 1. Let _patternIsRegExp_ be ? IsRegExp(_pattern_).
+ 1. If NewTarget is not *undefined*, let _newTarget_ be NewTarget.
+ 1. Else,
+ 1. Let _newTarget_ be the active function object.
+ 1. If _patternIsRegExp_ is *true* and _flags_ is *undefined*, then
+ 1. Let _patternConstructor_ be ? Get(_pattern_, `"constructor"`).
+ 1. If SameValue(_newTarget_, _patternConstructor_) is *true*, return _pattern_.
+ 1. If Type(_pattern_) is Object and _pattern_ has a [[RegExpMatcher]] internal slot, then
+ 1. Let _P_ be the value of _pattern_'s [[OriginalSource]] internal slot.
+ 1. If _flags_ is *undefined*, let _F_ be the value of _pattern_'s [[OriginalFlags]] internal slot.
+ 1. Else, let _F_ be _flags_.
+ 1. Else if _patternIsRegExp_ is *true*, then
+ 1. Let _P_ be ? Get(_pattern_, `"source"`).
+ 1. If _flags_ is *undefined*, then
+ 1. Let _F_ be ? Get(_pattern_, `"flags"`).
+ 1. Else, let _F_ be _flags_.
+ 1. Else,
+ 1. Let _P_ be _pattern_.
+ 1. Let _F_ be _flags_.
+ 1. Let _O_ be ? RegExpAlloc(_newTarget_).
+ 1. Return RegExpInitialize(_O_, _P_, _F_).
+
+
+
If pattern is supplied using a |StringLiteral|, the usual escape sequence substitutions are performed before the String is processed by RegExp. If pattern must contain an escape sequence to be recognized by RegExp, any U+005C (REVERSE SOLIDUS) code points must be escaped within the |StringLiteral| to prevent them being removed when the contents of the |StringLiteral| are formed.
+
+
+
+
+
+
Abstract Operations for the RegExp Constructor
+
+
+
+
Runtime Semantics: RegExpAlloc ( _newTarget_ )
+
When the abstract operation RegExpAlloc with argument _newTarget_ is called, the following steps are taken:
+
+ 1. Let _obj_ be ? OrdinaryCreateFromConstructor(_newTarget_, `"%RegExpPrototype%"`, « [[RegExpMatcher]], [[OriginalSource]], [[OriginalFlags]] »).
+ 1. Let _status_ be DefinePropertyOrThrow(_obj_, `"lastIndex"`, PropertyDescriptor {[[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false*}).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Return _obj_.
+
+
+
+
+
+
When the abstract operation RegExpInitialize with arguments _obj_, _pattern_, and _flags_ is called, the following steps are taken:
+
+ 1. If _pattern_ is *undefined*, let _P_ be the empty String.
+ 1. Else, let _P_ be ? ToString(_pattern_).
+ 1. If _flags_ is *undefined*, let _F_ be the empty String.
+ 1. Else, let _F_ be ? ToString(_flags_).
+ 1. If _F_ contains any code unit other than `"g"`, `"i"`, `"m"`, `"u"`, or `"y"` or if it contains the same code unit more than once, throw a *SyntaxError* exception.
+ 1. If _F_ contains `"u"`, let _BMP_ be *false*; else let _BMP_ be *true*.
+ 1. If _BMP_ is *true*, then
+ 1. Parse _P_ using the grammars in and interpreting each of its 16-bit elements as a Unicode BMP code point. UTF-16 decoding is not applied to the elements. The goal symbol for the parse is |Pattern|. Throw a *SyntaxError* exception if _P_ did not conform to the grammar, if any elements of _P_ were not matched by the parse, or if any Early Error conditions exist.
+ 1. Let _patternCharacters_ be a List whose elements are the code unit elements of _P_.
+ 1. Else,
+ 1. Parse _P_ using the grammars in and interpreting _P_ as UTF-16 encoded Unicode code points (). The goal symbol for the parse is |Pattern[U]|. Throw a *SyntaxError* exception if _P_ did not conform to the grammar, if any elements of _P_ were not matched by the parse, or if any Early Error conditions exist.
+ 1. Let _patternCharacters_ be a List whose elements are the code points resulting from applying UTF-16 decoding to _P_'s sequence of elements.
+ 1. Set the value of _obj_'s [[OriginalSource]] internal slot to _P_.
+ 1. Set the value of _obj_'s [[OriginalFlags]] internal slot to _F_.
+ 1. Set _obj_'s [[RegExpMatcher]] internal slot to the internal procedure that evaluates the above parse of _P_ by applying the semantics provided in using _patternCharacters_ as the pattern's List of |SourceCharacter| values and _F_ as the flag parameters.
+ 1. Perform ? Set(_obj_, `"lastIndex"`, 0, *true*).
+ 1. Return _obj_.
+
+
+
+
+
+
Runtime Semantics: RegExpCreate ( _P_, _F_ )
+
When the abstract operation RegExpCreate with arguments _P_ and _F_ is called, the following steps are taken:
+
+ 1. Let _obj_ be ? RegExpAlloc(%RegExp%).
+ 1. Return RegExpInitialize(_obj_, _P_, _F_).
+
+
+
+
+
+
When the abstract operation EscapeRegExpPattern with arguments _P_ and _F_ is called, the following occurs:
+
+ 1. Let _S_ be a String in the form of a |Pattern| (|Pattern[U]| if _F_ contains `"u"`) equivalent to _P_ interpreted as UTF-16 encoded Unicode code points (), in which certain code points are escaped as described below. _S_ may or may not be identical to _P_; however, the internal procedure that would result from evaluating _S_ as a |Pattern| (|Pattern[U]| if _F_ contains `"u"`) must behave identically to the internal procedure given by the constructed object's [[RegExpMatcher]] internal slot. Multiple calls to this abstract operation using the same values for _P_ and _F_ must produce identical results.
+ 1. The code points `/` or any |LineTerminator| occurring in the pattern shall be escaped in _S_ as necessary to ensure that the String value formed by concatenating the Strings `"/"`, _S_, `"/"`, and _F_ can be parsed (in an appropriate lexical context) as a |RegularExpressionLiteral| that behaves identically to the constructed regular expression. For example, if _P_ is `"/"`, then _S_ could be `"\\/"` or `"\\u002F"`, among other possibilities, but not `"/"`, because `///` followed by _F_ would be parsed as a |SingleLineComment| rather than a |RegularExpressionLiteral|. If _P_ is the empty String, this specification can be met by letting _S_ be `"(?:)"`.
+ 1. Return _S_.
+
+
+
+
+
+
+
+
Properties of the RegExp Constructor
+
The value of the [[Prototype]] internal slot of the RegExp constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 2), the RegExp constructor has the following properties:
+
+
+
+
RegExp.prototype
+
The initial value of `RegExp.prototype` is the intrinsic object %RegExpPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
get RegExp [ @@species ]
+
`RegExp[@@species]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
RegExp prototype methods normally use their `this` object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.
+
+
+
+
+
+
+
Properties of the RegExp Prototype Object
+
The RegExp prototype object is the intrinsic object %RegExpPrototype%. The RegExp prototype object is an ordinary object. It is not a RegExp instance and does not have a [[RegExpMatcher]] internal slot or any of the other internal slots of RegExp instance objects.
+
The value of the [[Prototype]] internal slot of the RegExp prototype object is the intrinsic object %ObjectPrototype% ().
+
+
The RegExp prototype object does not have a `valueOf` property of its own; however, it inherits the `valueOf` property from the Object prototype object.
+
+
+
+
+
RegExp.prototype.constructor
+
The initial value of `RegExp.prototype.constructor` is the intrinsic object %RegExp%.
+
+
+
+
+
RegExp.prototype.exec ( _string_ )
+
Performs a regular expression match of _string_ against the regular expression and returns an Array object containing the results of the match, or *null* if _string_ did not match.
+
The String ToString(_string_) is searched for an occurrence of the regular expression pattern as follows:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have a [[RegExpMatcher]] internal slot, throw a *TypeError* exception.
+ 1. Let _S_ be ? ToString(_string_).
+ 1. Return RegExpBuiltinExec(_R_, _S_).
+
+
+
+
+
Runtime Semantics: RegExpExec ( _R_, _S_ )
+
The abstract operation RegExpExec with arguments _R_ and _S_ performs the following steps:
+
+ 1. Assert: Type(_R_) is Object.
+ 1. Assert: Type(_S_) is String.
+ 1. Let _exec_ be ? Get(_R_, `"exec"`).
+ 1. If IsCallable(_exec_) is *true*, then
+ 1. Let _result_ be ? Call(_exec_, _R_, « _S_ »).
+ 1. If Type(_result_) is neither Object or Null, throw a *TypeError* exception.
+ 1. Return _result_.
+ 1. If _R_ does not have a [[RegExpMatcher]] internal slot, throw a *TypeError* exception.
+ 1. Return RegExpBuiltinExec(_R_, _S_).
+
+
+
If a callable `exec` property is not found this algorithm falls back to attempting to use the built-in RegExp matching algorithm. This provides compatible behaviour for code written for prior editions where most built-in algorithms that use regular expressions did not perform a dynamic property lookup of `exec`.
+
+
+
+
+
+
Runtime Semantics: RegExpBuiltinExec ( _R_, _S_ )
+
The abstract operation RegExpBuiltinExec with arguments _R_ and _S_ performs the following steps:
+
+ 1. Assert: _R_ is an initialized RegExp instance.
+ 1. Assert: Type(_S_) is String.
+ 1. Let _length_ be the number of code units in _S_.
+ 1. Let _lastIndex_ be ? ToLength(? Get(_R_,`"lastIndex"`)).
+ 1. Let _global_ be ToBoolean(? Get(_R_, `"global"`)).
+ 1. Let _sticky_ be ToBoolean(? Get(_R_, `"sticky"`)).
+ 1. If _global_ is *false* and _sticky_ is *false*, let _lastIndex_ be 0.
+ 1. Let _matcher_ be the value of _R_'s [[RegExpMatcher]] internal slot.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. If _flags_ contains `"u"`, let _fullUnicode_ be *true*, else let _fullUnicode_ be *false*.
+ 1. Let _matchSucceeded_ be *false*.
+ 1. Repeat, while _matchSucceeded_ is *false*
+ 1. If _lastIndex_ > _length_, then
+ 1. Perform ? Set(_R_, `"lastIndex"`, 0, *true*).
+ 1. Return *null*.
+ 1. Let _r_ be _matcher_(_S_, _lastIndex_).
+ 1. If _r_ is ~failure~, then
+ 1. If _sticky_ is *true*, then
+ 1. Perform ? Set(_R_, `"lastIndex"`, 0, *true*).
+ 1. Return *null*.
+ 1. Let _lastIndex_ be AdvanceStringIndex(_S_, _lastIndex_, _fullUnicode_).
+ 1. Else,
+ 1. Assert: _r_ is a State.
+ 1. Set _matchSucceeded_ to *true*.
+ 1. Let _e_ be _r_'s _endIndex_ value.
+ 1. If _fullUnicode_ is *true*, then
+ 1. _e_ is an index into the _Input_ character list, derived from _S_, matched by _matcher_. Let _eUTF_ be the smallest index into _S_ that corresponds to the character at element _e_ of _Input_. If _e_ is greater than or equal to the length of _Input_, then _eUTF_ is the number of code units in _S_.
+ 1. Let _e_ be _eUTF_.
+ 1. If _global_ is *true* or _sticky_ is *true*, then
+ 1. Perform ? Set(_R_, `"lastIndex"`, _e_, *true*).
+ 1. Let _n_ be the length of _r_'s _captures_ List. (This is the same value as 's _NcapturingParens_.)
+ 1. Let _A_ be ArrayCreate(_n_ + 1).
+ 1. Assert: The value of _A_'s `"length"` property is _n_ + 1.
+ 1. Let _matchIndex_ be _lastIndex_.
+ 1. Assert: The following CreateDataProperty calls will not result in an abrupt completion.
+ 1. Perform CreateDataProperty(_A_, `"index"`, _matchIndex_).
+ 1. Perform CreateDataProperty(_A_, `"input"`, _S_).
+ 1. Let _matchedSubstr_ be the matched substring (i.e. the portion of _S_ between offset _lastIndex_ inclusive and offset _e_ exclusive).
+ 1. Perform CreateDataProperty(_A_, `"0"`, _matchedSubstr_).
+ 1. For each integer _i_ such that _i_ > 0 and _i_ ≤ _n_
+ 1. Let _captureI_ be _i_th element of _r_'s _captures_ List.
+ 1. If _captureI_ is *undefined*, let _capturedValue_ be *undefined*.
+ 1. Else if _fullUnicode_ is *true*, then
+ 1. Assert: _captureI_ is a List of code points.
+ 1. Let _capturedValue_ be a string whose code units are the UTF16Encoding () of the code points of _captureI_.
+ 1. Else, _fullUnicode_ is *false*,
+ 1. Assert: _captureI_ is a List of code units.
+ 1. Let _capturedValue_ be a string consisting of the code units of _captureI_.
+ 1. Perform CreateDataProperty(_A_, ToString(_i_) , _capturedValue_).
+ 1. Return _A_.
+
+
+
+
+
+
AdvanceStringIndex ( _S_, _index_, _unicode_ )
+
The abstract operation AdvanceStringIndex with arguments _S_, _index_, and _unicode_ performs the following steps:
+
+ 1. Assert: Type(_S_) is String.
+ 1. Assert: _index_ is an integer such that 0≤_index_≤253-1.
+ 1. Assert: Type(_unicode_) is Boolean.
+ 1. If _unicode_ is *false*, return _index_+1.
+ 1. Let _length_ be the number of code units in _S_.
+ 1. If _index_+1 ≥ _length_, return _index_+1.
+ 1. Let _first_ be the code unit value at index _index_ in _S_.
+ 1. If _first_ < 0xD800 or _first_ > 0xDBFF, return _index_+1.
+ 1. Let _second_ be the code unit value at index _index_+1 in _S_.
+ 1. If _second_ < 0xDC00 or _second_ > 0xDFFF, return _index_+1.
+ 1. Return _index_+2.
+
+
+
+
+
+
+
get RegExp.prototype.flags
+
`RegExp.prototype.flags` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. Let _result_ be the empty String.
+ 1. Let _global_ be ToBoolean(? Get(_R_, `"global"`)).
+ 1. If _global_ is *true*, append `"g"` as the last code unit of _result_.
+ 1. Let _ignoreCase_ be ToBoolean(? Get(_R_, `"ignoreCase"`)).
+ 1. If _ignoreCase_ is *true*, append `"i"` as the last code unit of _result_.
+ 1. Let _multiline_ be ToBoolean(? Get(_R_, `"multiline"`)).
+ 1. If _multiline_ is *true*, append `"m"` as the last code unit of _result_.
+ 1. Let _unicode_ be ToBoolean(? Get(_R_, `"unicode"`)).
+ 1. If _unicode_ is *true*, append `"u"` as the last code unit of _result_.
+ 1. Let _sticky_ be ToBoolean(? Get(_R_, `"sticky"`)).
+ 1. If _sticky_ is *true*, append `"y"` as the last code unit of _result_.
+ 1. Return _result_.
+
+
+
+
+
+
get RegExp.prototype.global
+
`RegExp.prototype.global` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalFlags]] internal slot, throw a *TypeError* exception.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. If _flags_ contains the code unit `"g"`, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
get RegExp.prototype.ignoreCase
+
`RegExp.prototype.ignoreCase` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalFlags]] internal slot, throw a *TypeError* exception.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. If _flags_ contains the code unit `"i"`, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
RegExp.prototype [ @@match ] ( _string_ )
+
When the @@`match` method is called with argument _string_, the following steps are taken:
+
+ 1. Let _rx_ be the *this* value.
+ 1. If Type(_rx_) is not Object, throw a *TypeError* exception.
+ 1. Let _S_ be ? ToString(_string_).
+ 1. Let _global_ be ToBoolean(? Get(_rx_, `"global"`)).
+ 1. If _global_ is *false*, then
+ 1. Return RegExpExec(_rx_, _S_).
+ 1. Else _global_ is *true*,
+ 1. Let _fullUnicode_ be ToBoolean(? Get(_rx_, `"unicode"`)).
+ 1. Perform ? Set(_rx_, `"lastIndex"`, 0, *true*).
+ 1. Let _A_ be ArrayCreate(0).
+ 1. Let _n_ be 0.
+ 1. Repeat,
+ 1. Let _result_ be ? RegExpExec(_rx_, _S_).
+ 1. If _result_ is *null*, then
+ 1. If _n_=0, return *null*.
+ 1. Else, return _A_.
+ 1. Else _result_ is not *null*,
+ 1. Let _matchStr_ be ? ToString(? Get(_result_, `"0"`)).
+ 1. Let _status_ be CreateDataProperty(_A_, ToString(_n_), _matchStr_).
+ 1. Assert: _status_ is *true*.
+ 1. If _matchStr_ is the empty String, then
+ 1. Let _thisIndex_ be ? ToLength(? Get(_rx_, `"lastIndex"`)).
+ 1. Let _nextIndex_ be AdvanceStringIndex(_S_, _thisIndex_, _fullUnicode_).
+ 1. Perform ? Set(_rx_, `"lastIndex"`, _nextIndex_, *true*).
+ 1. Increment _n_.
+
+
The value of the `name` property of this function is `"[Symbol.match]"`.
+
+
The @@match property is used by the IsRegExp abstract operation to identify objects that have the basic behaviour of regular expressions. The absence of a @@match property or the existence of such a property whose value does not Boolean coerce to *true* indicates that the object is not intended to be used as a regular expression object.
+
+
+
+
+
+
get RegExp.prototype.multiline
+
`RegExp.prototype.multiline` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalFlags]] internal slot, throw a *TypeError* exception.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. If _flags_ contains the code unit `"m"`, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
When the @@`replace` method is called with arguments _string_ and _replaceValue_ the following steps are taken:
+
+ 1. Let _rx_ be the *this* value.
+ 1. If Type(_rx_) is not Object, throw a *TypeError* exception.
+ 1. Let _S_ be ? ToString(_string_).
+ 1. Let _lengthS_ be the number of code unit elements in _S_.
+ 1. Let _functionalReplace_ be IsCallable(_replaceValue_).
+ 1. If _functionalReplace_ is *false*, then
+ 1. Let _replaceValue_ be ? ToString(_replaceValue_).
+ 1. Let _global_ be ToBoolean(? Get(_rx_, `"global"`)).
+ 1. If _global_ is *true*, then
+ 1. Let _fullUnicode_ be ToBoolean(? Get(_rx_, `"unicode"`)).
+ 1. Perform ? Set(_rx_, `"lastIndex"`, 0, *true*).
+ 1. Let _results_ be a new empty List.
+ 1. Let _done_ be *false*.
+ 1. Repeat, while _done_ is *false*
+ 1. Let _result_ be ? RegExpExec(_rx_, _S_).
+ 1. If _result_ is *null*, set _done_ to *true*.
+ 1. Else _result_ is not *null*,
+ 1. Append _result_ to the end of _results_.
+ 1. If _global_ is *false*, set _done_ to *true*.
+ 1. Else,
+ 1. Let _matchStr_ be ? ToString(? Get(_result_, `"0"`)).
+ 1. If _matchStr_ is the empty String, then
+ 1. Let _thisIndex_ be ? ToLength(? Get(_rx_, `"lastIndex"`)).
+ 1. Let _nextIndex_ be AdvanceStringIndex(_S_, _thisIndex_, _fullUnicode_).
+ 1. Perform ? Set(_rx_, `"lastIndex"`, _nextIndex_, *true*).
+ 1. Let _accumulatedResult_ be the empty String value.
+ 1. Let _nextSourcePosition_ be 0.
+ 1. Repeat, for each _result_ in _results_,
+ 1. Let _nCaptures_ be ? ToLength(? Get(_result_, `"length"`)).
+ 1. Let _nCaptures_ be max(_nCaptures_ - 1, 0).
+ 1. Let _matched_ be ? ToString(? Get(_result_, `"0"`)).
+ 1. Let _matchLength_ be the number of code units in _matched_.
+ 1. Let _position_ be ? ToInteger(? Get(_result_, `"index"`)).
+ 1. Let _position_ be max(min(_position_, _lengthS_), 0).
+ 1. Let _n_ be 1.
+ 1. Let _captures_ be an empty List.
+ 1. Repeat while _n_ ≤ _nCaptures_
+ 1. Let _capN_ be ? Get(_result_, ToString(_n_)).
+ 1. If _capN_ is not *undefined*, then
+ 1. Let _capN_ be ? ToString(_capN_).
+ 1. Append _capN_ as the last element of _captures_.
+ 1. Let _n_ be _n_+1.
+ 1. If _functionalReplace_ is *true*, then
+ 1. Let _replacerArgs_ be « _matched_ ».
+ 1. Append in list order the elements of _captures_ to the end of the List _replacerArgs_.
+ 1. Append _position_ and _S_ as the last two elements of _replacerArgs_.
+ 1. Let _replValue_ be ? Call(_replaceValue_, *undefined*, _replacerArgs_).
+ 1. Let _replacement_ be ? ToString(_replValue_).
+ 1. Else,
+ 1. Let _replacement_ be GetSubstitution(_matched_, _S_, _position_, _captures_, _replaceValue_).
+ 1. If _position_ ≥ _nextSourcePosition_, then
+ 1. NOTE _position_ should not normally move backwards. If it does, it is an indication of an ill-behaving RegExp subclass or use of an access triggered side-effect to change the global flag or other characteristics of _rx_. In such cases, the corresponding substitution is ignored.
+ 1. Let _accumulatedResult_ be the String formed by concatenating the code units of the current value of _accumulatedResult_ with the substring of _S_ consisting of the code units from _nextSourcePosition_ (inclusive) up to _position_ (exclusive) and with the code units of _replacement_.
+ 1. Let _nextSourcePosition_ be _position_ + _matchLength_.
+ 1. If _nextSourcePosition_ ≥ _lengthS_, return _accumulatedResult_.
+ 1. Return the String formed by concatenating the code units of _accumulatedResult_ with the substring of _S_ consisting of the code units from _nextSourcePosition_ (inclusive) up through the final code unit of _S_ (inclusive).
+
+
The value of the `name` property of this function is `"[Symbol.replace]"`.
+
+
+
+
+
RegExp.prototype [ @@search ] ( _string_ )
+
When the @@search method is called with argument _string_, the following steps are taken:
+
+ 1. Let _rx_ be the *this* value.
+ 1. If Type(_rx_) is not Object, throw a *TypeError* exception.
+ 1. Let _S_ be ? ToString(_string_).
+ 1. Let _previousLastIndex_ be ? Get(_rx_, `"lastIndex"`).
+ 1. Let _status_ be ? Set(_rx_, `"lastIndex"`, 0, *true*).
+ 1. Let _result_ be ? RegExpExec(_rx_, _S_).
+ 1. Let _status_ be ? Set(_rx_, `"lastIndex"`, _previousLastIndex_, *true*).
+ 1. If _result_ is *null*, return -1.
+ 1. Return Get(_result_, `"index"`).
+
+
The value of the `name` property of this function is `"[Symbol.search]"`.
+
+
The `lastIndex` and `global` properties of this RegExp object are ignored when performing the search. The `lastIndex` property is left unchanged.
+
+
+
+
+
+
get RegExp.prototype.source
+
`RegExp.prototype.source` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalSource]] internal slot, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalFlags]] internal slot, throw a *TypeError* exception.
+ 1. Let _src_ be the value of _R_'s [[OriginalSource]] internal slot.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. Return EscapeRegExpPattern(_src_, _flags_).
+
+
+
+
+
+
Returns an Array object into which substrings of the result of converting _string_ to a String have been stored. The substrings are determined by searching from left to right for matches of the *this* value regular expression; these occurrences are not part of any substring in the returned array, but serve to divide up the String value.
+
The *this* value may be an empty regular expression or a regular expression that can match an empty String. In this case, regular expression does not match the empty substring at the beginning or end of the input String, nor does it match the empty substring at the end of the previous separator match. (For example, if the regular expression matches the empty String, the String is split up into individual code unit elements; the length of the result array equals the length of the String, and each substring contains one code unit.) Only the first match at a given index of the *this* String is considered, even if backtracking could yield a non-empty-substring match at that index. (For example, `/a*?/[Symbol.split]("ab")` evaluates to the array `["a","b"]`, while `/a*/[Symbol.split]("ab")` evaluates to the array `["","b"]`.)
+
If the _string_ is (or converts to) the empty String, the result depends on whether the regular expression can match the empty String. If it can, the result array contains no elements. Otherwise, the result array contains one element, which is the empty String.
+
If the regular expression that contains capturing parentheses, then each time _separator_ is matched the results (including any *undefined* results) of the capturing parentheses are spliced into the output array. For example,
If _limit_ is not *undefined*, then the output array is truncated so that it contains no more than _limit_ elements.
+
+
When the @@`split` method is called, the following steps are taken:
+
+ 1. Let _rx_ be the *this* value.
+ 1. If Type(_rx_) is not Object, throw a *TypeError* exception.
+ 1. Let _S_ be ? ToString(_string_).
+ 1. Let _C_ be ? SpeciesConstructor(_rx_, %RegExp%).
+ 1. Let _flags_ be ? ToString(? Get(_rx_, `"flags"`)).
+ 1. If _flags_ contains `"u"`, let _unicodeMatching_ be *true*.
+ 1. Else, let _unicodeMatching_ be *false*.
+ 1. If _flags_ contains `"y"`, let _newFlags_ be _flags_.
+ 1. Else, let _newFlags_ be the string that is the concatenation of _flags_ and `"y"`.
+ 1. Let _splitter_ be ? Construct(_C_, « _rx_, _newFlags_ »).
+ 1. Let _A_ be ArrayCreate(0).
+ 1. Let _lengthA_ be 0.
+ 1. If _limit_ is *undefined*, let _lim_ be 232-1; else let _lim_ be ? ToUint32(_limit_).
+ 1. Let _size_ be the number of elements in _S_.
+ 1. Let _p_ be 0.
+ 1. If _lim_ = 0, return _A_.
+ 1. If _size_ = 0, then
+ 1. Let _z_ be ? RegExpExec(_splitter_, _S_).
+ 1. If _z_ is not *null*, return _A_.
+ 1. Assert: The following call will never result in an abrupt completion.
+ 1. Perform CreateDataProperty(_A_, `"0"`, _S_).
+ 1. Return _A_.
+ 1. Let _q_ be _p_.
+ 1. Repeat, while _q_ < _size_
+ 1. Perform ? Set(_splitter_, `"lastIndex"`, _q_, *true*).
+ 1. Let _z_ be ? RegExpExec(_splitter_, _S_).
+ 1. If _z_ is *null*, let _q_ be AdvanceStringIndex(_S_, _q_, _unicodeMatching_).
+ 1. Else _z_ is not *null*,
+ 1. Let _e_ be ? ToLength(Get(_splitter_, `"lastIndex"`)).
+ 1. Let _e_ be min(_e_, _size_).
+ 1. If _e_ = _p_, let _q_ be AdvanceStringIndex(_S_, _q_, _unicodeMatching_).
+ 1. Else _e_ ≠ _p_,
+ 1. Let _T_ be a String value equal to the substring of _S_ consisting of the elements at indices _p_ (inclusive) through _q_ (exclusive).
+ 1. Assert: The following call will never result in an abrupt completion.
+ 1. Perform CreateDataProperty(_A_, ToString(_lengthA_), _T_).
+ 1. Let _lengthA_ be _lengthA_ +1.
+ 1. If _lengthA_ = _lim_, return _A_.
+ 1. Let _p_ be _e_.
+ 1. Let _numberOfCaptures_ be ? ToLength(? Get(_z_, `"length"`)).
+ 1. Let _numberOfCaptures_ be max(_numberOfCaptures_-1, 0).
+ 1. Let _i_ be 1.
+ 1. Repeat, while _i_ ≤ _numberOfCaptures_.
+ 1. Let _nextCapture_ be ? Get(_z_, ToString(_i_)).
+ 1. Perform CreateDataProperty(_A_, ToString(_lengthA_), _nextCapture_).
+ 1. Let _i_ be _i_ +1.
+ 1. Let _lengthA_ be _lengthA_ +1.
+ 1. If _lengthA_ = _lim_, return _A_.
+ 1. Let _q_ be _p_.
+ 1. Let _T_ be a String value equal to the substring of _S_ consisting of the elements at indices _p_ (inclusive) through _size_ (exclusive).
+ 1. Assert: The following call will never result in an abrupt completion.
+ 1. Perform CreateDataProperty(_A_, ToString(_lengthA_), _T_ ).
+ 1. Return _A_.
+
+
The value of the `name` property of this function is `"[Symbol.split]"`.
+
+
The @@`split` method ignores the value of the `global` and `sticky` properties of this RegExp object.
+
+
+
+
+
+
get RegExp.prototype.sticky
+
`RegExp.prototype.sticky` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalFlags]] internal slot, throw a *TypeError* exception.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. If _flags_ contains the code unit `"y"`, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
RegExp.prototype.test( _S_ )
+
The following steps are taken:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. Let _string_ be ? ToString(_S_).
+ 1. Let _match_ be ? RegExpExec(_R_, _string_).
+ 1. If _match_ is not *null*, return *true*; else return *false*.
+
+
+
+
+
+
RegExp.prototype.toString ( )
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. Let _pattern_ be ? ToString(? Get(_R_, `"source"`)).
+ 1. Let _flags_ be ? ToString(? Get(_R_, `"flags"`)).
+ 1. Let _result_ be the String value formed by concatenating `"/"`, _pattern_, and `"/"`, and _flags_.
+
+
+
The returned String has the form of a |RegularExpressionLiteral| that evaluates to another RegExp object with the same behaviour as this object.
+
+
+
+
+
+
get RegExp.prototype.unicode
+
`RegExp.prototype.unicode` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _R_ be the *this* value.
+ 1. If Type(_R_) is not Object, throw a *TypeError* exception.
+ 1. If _R_ does not have an [[OriginalFlags]] internal slot, throw a *TypeError* exception.
+ 1. Let _flags_ be the value of _R_'s [[OriginalFlags]] internal slot.
+ 1. If _flags_ contains the code unit `"u"`, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
+
Properties of RegExp Instances
+
RegExp instances are ordinary objects that inherit properties from the RegExp prototype object. RegExp instances have internal slots [[RegExpMatcher]], [[OriginalSource]], and [[OriginalFlags]]. The value of the [[RegExpMatcher]] internal slot is an implementation dependent representation of the |Pattern| of the RegExp object.
+
+
Prior to ECMAScript 2015, `RegExp` instances were specified as having the own data properties `source`, `global`, `ignoreCase`, and `multiline`. Those properties are now specified as accessor properties of RegExp.prototype.
+
+
RegExp instances also have the following property:
+
+
+
+
lastIndex
+
The value of the `lastIndex` property specifies the String index at which to start the next match. It is coerced to an integer when used (see ). This property shall have the attributes { [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
+
+
Indexed Collections
+
+
+
+
Array Objects
+
Array objects are exotic objects that give special treatment to a certain class of property names. See for a definition of this special treatment.
+
+
+
+
The Array Constructor
+
The Array constructor is the %Array% intrinsic object and the initial value of the `Array` property of the global object. When called as a constructor it creates and initializes a new exotic Array object. When `Array` is called as a function rather than as a constructor, it also creates and initializes a new Array object. Thus the function call `Array(…)` is equivalent to the object creation expression `new Array(…)` with the same arguments.
+
The `Array` constructor is a single function whose behaviour is overloaded based upon the number and types of its arguments.
+
The `Array` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the exotic `Array` behaviour must include a `super` call to the `Array` constructor to initialize subclass instances that are exotic Array objects. However, most of the `Array.prototype` methods are generic methods that are not dependent upon their `this` value being an exotic Array object.
+
The `length` property of the `Array` constructor function is 1.
+
+
+
+
Array ( )
+
This description applies if and only if the Array constructor is called with no arguments.
+
+ 1. Let _numberOfArgs_ be the number of arguments passed to this function call.
+ 1. Assert: _numberOfArgs_ = 0.
+ 1. If NewTarget is *undefined*, let _newTarget_ be the active function object, else let _newTarget_ be NewTarget.
+ 1. Let _proto_ be ? GetPrototypeFromConstructor(_newTarget_, `"%ArrayPrototype%"`).
+ 1. Return ArrayCreate(0, _proto_).
+
+
+
+
+
+
Array (_len_)
+
This description applies if and only if the Array constructor is called with exactly one argument.
+
+ 1. Let _numberOfArgs_ be the number of arguments passed to this function call.
+ 1. Assert: _numberOfArgs_ = 1.
+ 1. If NewTarget is *undefined*, let _newTarget_ be the active function object, else let _newTarget_ be NewTarget.
+ 1. Let _proto_ be ? GetPrototypeFromConstructor(_newTarget_, `"%ArrayPrototype%"`).
+ 1. Let _array_ be ArrayCreate(0, _proto_).
+ 1. If Type(_len_) is not Number, then
+ 1. Let _defineStatus_ be CreateDataProperty(_array_, `"0"`, _len_).
+ 1. Assert: _defineStatus_ is *true*.
+ 1. Let _intLen_ be 1.
+ 1. Else,
+ 1. Let _intLen_ be ToUint32(_len_).
+ 1. If _intLen_ ≠ _len_, throw a *RangeError* exception.
+ 1. Let _setStatus_ be Set(_array_, `"length"`, _intLen_, *true*).
+ 1. Assert: _setStatus_ is not an abrupt completion.
+ 1. Return _array_.
+
+
+
+
+
+
Array (..._items_ )
+
This description applies if and only if the Array constructor is called with at least two arguments.
+
When the `Array` function is called the following steps are taken:
+
+ 1. Let _numberOfArgs_ be the number of arguments passed to this function call.
+ 1. Assert: _numberOfArgs_ ≥ 2.
+ 1. If NewTarget is *undefined*, let _newTarget_ be the active function object, else let _newTarget_ be NewTarget.
+ 1. Let _proto_ be ? GetPrototypeFromConstructor(_newTarget_, `"%ArrayPrototype%"`).
+ 1. Let _array_ be ? ArrayCreate(_numberOfArgs_, _proto_).
+ 1. Let _k_ be 0.
+ 1. Let _items_ be a zero-origined List containing the argument items in order.
+ 1. Repeat, while _k_ < _numberOfArgs_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _itemK_ be _items_[_k_].
+ 1. Let _defineStatus_ be CreateDataProperty(_array_, _Pk_, _itemK_).
+ 1. Assert: _defineStatus_ is *true*.
+ 1. Increase _k_ by 1.
+ 1. Assert: the value of _array_'s `length` property is _numberOfArgs_.
+ 1. Return _array_.
+
+
+
+
+
+
+
Properties of the Array Constructor
+
The value of the [[Prototype]] internal slot of the Array constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 1), the Array constructor has the following properties:
When the `from` method is called with argument _items_ and optional arguments _mapfn_ and _thisArg_ the following steps are taken:
+
+ 1. Let _C_ be the *this* value.
+ 1. If _mapfn_ is *undefined*, let _mapping_ be *false*.
+ 1. Else,
+ 1. If IsCallable(_mapfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _mapping_ be *true*.
+ 1. Let _usingIterator_ be ? GetMethod(_items_, @@iterator).
+ 1. If _usingIterator_ is not *undefined*, then
+ 1. If IsConstructor(_C_) is *true*, then
+ 1. Let _A_ be Construct(_C_).
+ 1. Else,
+ 1. Let _A_ be ArrayCreate(0).
+ 1. ReturnIfAbrupt(_A_).
+ 1. Let _iterator_ be ? GetIterator(_items_, _usingIterator_).
+ 1. Let _k_ be 0.
+ 1. Repeat
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _next_ be ? IteratorStep(_iterator_).
+ 1. If _next_ is *false*, then
+ 1. Perform ? Set(_A_, `"length"`, _k_, *true*).
+ 1. Return _A_.
+ 1. Let _nextValue_ be ? IteratorValue(_next_).
+ 1. If _mapping_ is *true*, then
+ 1. Let _mappedValue_ be Call(_mapfn_, _T_, « _nextValue_, _k_ »).
+ 1. If _mappedValue_ is an abrupt completion, return IteratorClose(_iterator_, _mappedValue_).
+ 1. Let _mappedValue_ be _mappedValue_.[[value]].
+ 1. Else, let _mappedValue_ be _nextValue_.
+ 1. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+ 1. If _defineStatus_ is an abrupt completion, return IteratorClose(_iterator_, _defineStatus_).
+ 1. Increase _k_ by 1.
+ 1. Assert: _items_ is not an Iterable so assume it is an array-like object.
+ 1. Let _arrayLike_ be ? ToObject(_items_).
+ 1. Let _len_ be ? ToLength(? Get(_arrayLike_, `"length"`)).
+ 1. If IsConstructor(_C_) is *true*, then
+ 1. Let _A_ be Construct(_C_, « _len_ »).
+ 1. Else,
+ 1. Let _A_ be ArrayCreate(_len_).
+ 1. ReturnIfAbrupt(_A_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_arrayLike_, _Pk_).
+ 1. If _mapping_ is *true*, then
+ 1. Let _mappedValue_ be ? Call(_mapfn_, _T_, « _kValue_, _k_ »).
+ 1. Else, let _mappedValue_ be _kValue_.
+ 1. Perform ? CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+ 1. Increase _k_ by 1.
+ 1. Perform ? Set(_A_, `"length"`, _len_, *true*).
+ 1. Return _A_.
+
+
The `length` property of the `from` method is 1.
+
+
The `from` function is an intentionally generic factory method; it does not require that its *this* value be the Array constructor. Therefore it can be transferred to or inherited by any other constructors that may be called with a single numeric argument.
+
+
+
+
+
+
Array.isArray ( _arg_ )
+
The `isArray` function takes one argument _arg_, and performs the following steps:
+
+ 1. Return IsArray(_arg_).
+
+
+
+
+
+
Array.of ( ..._items_ )
+
When the `of` method is called with any number of arguments, the following steps are taken:
+
+ 1. Let _len_ be the actual number of arguments passed to this function.
+ 1. Let _items_ be the List of arguments passed to this function.
+ 1. Let _C_ be the *this* value.
+ 1. If IsConstructor(_C_) is *true*, then
+ 1. Let _A_ be Construct(_C_, « _len_ »).
+ 1. Else,
+ 1. Let _A_ be ArrayCreate(_len_).
+ 1. ReturnIfAbrupt(_A_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _kValue_ be _items_[_k_].
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Perform ? CreateDataPropertyOrThrow(_A_,_Pk_, _kValue_).
+ 1. Increase _k_ by 1.
+ 1. Perform ? Set(_A_, `"length"`, _len_, *true*).
+ 1. Return _A_.
+
+
The `length` property of the `of` method is 0.
+
+
The _items_ argument is assumed to be a well-formed rest argument value.
+
+
+
The `of` function is an intentionally generic factory method; it does not require that its *this* value be the Array constructor. Therefore it can be transferred to or inherited by other constructors that may be called with a single numeric argument.
+
+
+
+
+
+
Array.prototype
+
The value of `Array.prototype` is %ArrayPrototype%, the intrinsic Array prototype object ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
get Array [ @@species ]
+
`Array[@@species]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
Array prototype methods normally use their `this` object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.
+
+
+
+
+
+
+
Properties of the Array Prototype Object
+
The Array prototype object is the intrinsic object %ArrayPrototype%. The Array prototype object is an Array exotic objects and has the internal methods specified for such objects. It has a `length` property whose initial value is 0 and whose attributes are { [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
The value of the [[Prototype]] internal slot of the Array prototype object is the intrinsic object %ObjectPrototype%.
+
+
The Array prototype object is specified to be an Array exotic object to ensure compatibility with ECMAScript code that was created prior to the ECMAScript 2015 specification.
+
+
+
+
+
Array.prototype.concat ( ..._arguments_ )
+
When the `concat` method is called with zero or more arguments, it returns an array containing the array elements of the object followed by the array elements of each argument in order.
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _A_ be ? ArraySpeciesCreate(_O_, 0).
+ 1. Let _n_ be 0.
+ 1. Let _items_ be a List whose first element is _O_ and whose subsequent elements are, in left to right order, the arguments that were passed to this function invocation.
+ 1. Repeat, while _items_ is not empty
+ 1. Remove the first element from _items_ and let _E_ be the value of the element.
+ 1. Let _spreadable_ be ? IsConcatSpreadable(_E_).
+ 1. If _spreadable_ is *true*, then
+ 1. Let _k_ be 0.
+ 1. Let _len_ be ? ToLength(? Get(_E_, `"length"`)).
+ 1. If _n_ + _len_ > 253-1, throw a *TypeError* exception.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _P_ be ToString(_k_).
+ 1. Let _exists_ be ? HasProperty(_E_, _P_).
+ 1. If _exists_ is *true*, then
+ 1. Let _subElement_ be ? Get(_E_, _P_).
+ 1. Let _status_ be ? CreateDataPropertyOrThrow(_A_, ToString(_n_), _subElement_).
+ 1. Increase _n_ by 1.
+ 1. Increase _k_ by 1.
+ 1. Else _E_ is added as a single item rather than spread,
+ 1. If _n_≥253-1, throw a *TypeError* exception.
+ 1. Let _status_ be ? CreateDataPropertyOrThrow(_A_, ToString(_n_), _E_).
+ 1. Increase _n_ by 1.
+ 1. Perform ? Set(_A_, `"length"`, _n_, *true*).
+ 1. Return _A_.
+
+
The `length` property of the `concat` method is 1.
+
+
The explicit setting of the `length` property in step 6 is necessary to ensure that its value is correct in situations where the trailing elements of the result Array are not present.
+
+
+
The `concat` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
Runtime Semantics: IsConcatSpreadable ( _O_ )
+
The abstract operation IsConcatSpreadable with argument _O_ performs the following steps:
+
+ 1. If Type(_O_) is not Object, return *false*.
+ 1. Let _spreadable_ be ? Get(_O_, @@isConcatSpreadable).
+ 1. If _spreadable_ is not *undefined*, return ToBoolean(_spreadable_).
+ 1. Return IsArray(_O_).
+
+
+
+
+
+
+
Array.prototype.constructor
+
The initial value of `Array.prototype.constructor` is the intrinsic object %Array%.
The `copyWithin` method takes up to three arguments _target_, _start_ and _end_.
+
+
The _end_ argument is optional with the length of the *this* object as its default value. If _target_ is negative, it is treated as _length_+_target_ where _length_ is the length of the array. If _start_ is negative, it is treated as _length_+_start_. If _end_ is negative, it is treated as _length_+_end_.
+
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _relativeTarget_ be ? ToInteger(_target_).
+ 1. If _relativeTarget_ < 0, let _to_ be max((_len_ + _relativeTarget_),0); else let _to_ be min(_relativeTarget_, _len_).
+ 1. Let _relativeStart_ be ? ToInteger(_start_).
+ 1. If _relativeStart_ < 0, let _from_ be max((_len_ + _relativeStart_),0); else let _from_ be min(_relativeStart_, _len_).
+ 1. If _end_ is *undefined*, let _relativeEnd_ be _len_; else let _relativeEnd_ be ? ToInteger(_end_).
+ 1. If _relativeEnd_ < 0, let _final_ be max((_len_ + _relativeEnd_),0); else let _final_ be min(_relativeEnd_, _len_).
+ 1. Let _count_ be min(_final_-_from_, _len_-_to_).
+ 1. If _from_<_to_ and _to_<_from_+_count_, then
+ 1. Let _direction_ be -1.
+ 1. Let _from_ be _from_ + _count_ -1.
+ 1. Let _to_ be _to_ + _count_ -1.
+ 1. Else,
+ 1. Let _direction_ be 1.
+ 1. Repeat, while _count_ > 0
+ 1. Let _fromKey_ be ToString(_from_).
+ 1. Let _toKey_ be ToString(_to_).
+ 1. Let _fromPresent_ be ? HasProperty(_O_, _fromKey_).
+ 1. If _fromPresent_ is *true*, then
+ 1. Let _fromVal_ be ? Get(_O_, _fromKey_).
+ 1. Perform ? Set(_O_, _toKey_, _fromVal_, *true*).
+ 1. Else _fromPresent_ is *false*,
+ 1. Perform ? DeletePropertyOrThrow(_O_, _toKey_).
+ 1. Let _from_ be _from_ + _direction_.
+ 1. Let _to_ be _to_ + _direction_.
+ 1. Let _count_ be _count_ - 1.
+ 1. Return _O_.
+
+
The `length` property of the `copyWithin` method is 2.
+
+
The `copyWithin` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.entries ( )
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Return CreateArrayIterator(_O_, `"key+value"`).
+
+
+
+
+
+
_callbackfn_ should be a function that accepts three arguments and returns a value that is coercible to the Boolean value *true* or *false*. `every` calls _callbackfn_ once for each element present in the array, in ascending order, until it finds one where _callbackfn_ returns *false*. If such an element is found, `every` immediately returns *false*. Otherwise, if _callbackfn_ returned *true* for all elements, `every` will return *true*. _callbackfn_ is called only for elements of the array which actually exist; it is not called for missing elements of the array.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`every` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
The range of elements processed by `every` is set before the first call to _callbackfn_. Elements which are appended to the array after the call to `every` begins will not be visited by _callbackfn_. If existing elements of the array are changed, their value as passed to _callbackfn_ will be the value at the time `every` visits them; elements that are deleted after the call to `every` begins and before being visited are not visited. `every` acts like the "for all" quantifier in mathematics. In particular, for an empty array, it returns *true*.
+
+
When the `every` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _testResult_ be ToBoolean(? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »)).
+ 1. If _testResult_ is *false*, return *false*.
+ 1. Increase _k_ by 1.
+ 1. Return *true*.
+
+
The `length` property of the `every` method is 1.
+
+
The `every` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
The `fill` method takes up to three arguments _value_, _start_ and _end_.
+
+
The _start_ and _end_ arguments are optional with default values of 0 and the length of the *this* object. If _start_ is negative, it is treated as _length_+_start_ where _length_ is the length of the array. If _end_ is negative, it is treated as _length_+_end_.
+
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _relativeStart_ be ? ToInteger(_start_).
+ 1. If _relativeStart_ < 0, let _k_ be max((_len_ + _relativeStart_),0); else let _k_ be min(_relativeStart_, _len_).
+ 1. If _end_ is *undefined*, let _relativeEnd_ be _len_; else let _relativeEnd_ be ? ToInteger(_end_).
+ 1. If _relativeEnd_ < 0, let _final_ be max((_len_ + _relativeEnd_),0); else let _final_ be min(_relativeEnd_, _len_).
+ 1. Repeat, while _k_ < _final_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Perform ? Set(_O_, _Pk_, _value_, *true*).
+ 1. Increase _k_ by 1.
+ 1. Return _O_.
+
+
The `length` property of the `fill` method is 1.
+
+
The `fill` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_callbackfn_ should be a function that accepts three arguments and returns a value that is coercible to the Boolean value *true* or *false*. `filter` calls _callbackfn_ once for each element in the array, in ascending order, and constructs a new array of all the values for which _callbackfn_ returns *true*. _callbackfn_ is called only for elements of the array which actually exist; it is not called for missing elements of the array.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`filter` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
The range of elements processed by `filter` is set before the first call to _callbackfn_. Elements which are appended to the array after the call to `filter` begins will not be visited by _callbackfn_. If existing elements of the array are changed their value as passed to _callbackfn_ will be the value at the time `filter` visits them; elements that are deleted after the call to `filter` begins and before being visited are not visited.
+
+
When the `filter` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _A_ be ? ArraySpeciesCreate(_O_, 0).
+ 1. Let _k_ be 0.
+ 1. Let _to_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _selected_ be ToBoolean(? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »)).
+ 1. If _selected_ is *true*, then
+ 1. Let _status_ be ? CreateDataPropertyOrThrow(_A_, ToString(_to_), _kValue_).
+ 1. Increase _to_ by 1.
+ 1. Increase _k_ by 1.
+ 1. Return _A_.
+
+
The `length` property of the `filter` method is 1.
+
+
The `filter` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
The `find` method is called with one or two arguments, _predicate_ and _thisArg_.
+
+
_predicate_ should be a function that accepts three arguments and returns a value that is coercible to a Boolean value. `find` calls _predicate_ once for each element of the array, in ascending order, until it finds one where _predicate_ returns *true*. If such an element is found, `find` immediately returns that element value. Otherwise, `find` returns *undefined*.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _predicate_. If it is not provided, *undefined* is used instead.
+
_predicate_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`find` does not directly mutate the object on which it is called but the object may be mutated by the calls to _predicate_.
+
The range of elements processed by `find` is set before the first call to _callbackfn_. Elements that are appended to the array after the call to `find` begins will not be visited by _callbackfn_. If existing elements of the array are changed, their value as passed to _predicate_ will be the value at the time that `find` visits them.
+
+
When the `find` method is called, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_predicate_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _testResult_ be ToBoolean(? Call(_predicate_, _T_, « _kValue_, _k_, _O_ »)).
+ 1. If _testResult_ is *true*, return _kValue_.
+ 1. Increase _k_ by 1.
+ 1. Return *undefined*.
+
+
The `length` property of the `find` method is 1.
+
+
The `find` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_predicate_ should be a function that accepts three arguments and returns a value that is coercible to the Boolean value *true* or *false*. `findIndex` calls _predicate_ once for each element of the array, in ascending order, until it finds one where _predicate_ returns *true*. If such an element is found, `findIndex` immediately returns the index of that element value. Otherwise, `findIndex` returns -1.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _predicate_. If it is not provided, *undefined* is used instead.
+
_predicate_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`findIndex` does not directly mutate the object on which it is called but the object may be mutated by the calls to _predicate_.
+
The range of elements processed by `findIndex` is set before the first call to _callbackfn_. Elements that are appended to the array after the call to `findIndex` begins will not be visited by _callbackfn_. If existing elements of the array are changed, their value as passed to _predicate_ will be the value at the time that `findIndex` visits them.
+
+
When the `findIndex` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_predicate_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _testResult_ be ToBoolean(? Call(_predicate_, _T_, « _kValue_, _k_, _O_ »)).
+ 1. If _testResult_ is *true*, return _k_.
+ 1. Increase _k_ by 1.
+ 1. Return -1.
+
+
The `length` property of the `findIndex` method is 1.
+
+
The `findIndex` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_callbackfn_ should be a function that accepts three arguments. `forEach` calls _callbackfn_ once for each element present in the array, in ascending order. _callbackfn_ is called only for elements of the array which actually exist; it is not called for missing elements of the array.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`forEach` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
+
When the `forEach` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Perform ? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »).
+ 1. Increase _k_ by 1.
+ 1. Return *undefined*.
+
+
The `length` property of the `forEach` method is 1.
+
+
The `forEach` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
`includes` compares _searchElement_ to the elements of the array, in ascending order, using the SameValueZero algorithm, and if found at any position, returns *true*; otherwise, *false* is returned.
+
+
The optional second argument _fromIndex_ defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, *false* is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute _fromIndex_. If the computed index is less than 0, the whole array will be searched.
+
+
+
When the `includes` method is called, the following steps are taken:
+
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If _len_ is 0, return *false*.
+ 1. Let _n_ be ? ToInteger(_fromIndex_). (If _fromIndex_ is *undefined*, this step produces the value 0.)
+ 1. If _n_ ≥ 0, then
+ 1. Let _k_ be _n_.
+ 1. Else _n_ < 0,
+ 1. Let _k_ be _len_ + _n_.
+ 1. If _k_ < 0, let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _elementK_ be the result of ? Get(_O_, ToString(_k_)).
+ 1. If SameValueZero(_searchElement_, _elementK_) is *true*, return *true*.
+ 1. Increase _k_ by 1.
+ 1. Return *false*.
+
+
+
The `length` property of the `includes` method is *1*.
+
+
+ The `includes` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+ The `includes` method intentionally differs from the similar `indexOf` method in two ways. First, it uses the SameValueZero algorithm, instead of Strict Equality Comparison, allowing it to detect *NaN* array elements. Second, it does not skip missing array elements, instead treating them as *undefined*.
+
+
+
+
+
+
`indexOf` compares _searchElement_ to the elements of the array, in ascending order, using the Strict Equality Comparison algorithm (), and if found at one or more indices, returns the smallest such index; otherwise, -1 is returned.
+
The optional second argument _fromIndex_ defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, -1 is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute _fromIndex_. If the computed index is less than 0, the whole array will be searched.
+
+
When the `indexOf` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If _len_ is 0, return -1.
+ 1. Let _n_ be ? ToInteger(_fromIndex_). (If _fromIndex_ is *undefined*, this step produces the value 0.)
+ 1. If _n_ ≥ _len_, return -1.
+ 1. If _n_ ≥ 0, then
+ 1. Let _k_ be _n_.
+ 1. Else _n_ < 0,
+ 1. Let _k_ be _len_ + _n_.
+ 1. If _k_ < 0, let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _kPresent_ be ? HasProperty(_O_, ToString(_k_)).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _elementK_ be ? Get(_O_, ToString(_k_)).
+ 1. Let _same_ be the result of performing Strict Equality Comparison _searchElement_ === _elementK_.
+ 1. If _same_ is *true*, return _k_.
+ 1. Increase _k_ by 1.
+ 1. Return -1.
+
+
The `length` property of the `indexOf` method is 1.
+
+
The `indexOf` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.join (_separator_)
+
+
The elements of the array are converted to Strings, and these Strings are then concatenated, separated by occurrences of the _separator_. If no separator is provided, a single comma is used as the separator.
+
+
The `join` method takes one argument, _separator_, and performs the following steps:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If _separator_ is *undefined*, let _separator_ be the single-element String `","`.
+ 1. Let _sep_ be ? ToString(_separator_).
+ 1. If _len_ is zero, return the empty String.
+ 1. Let _element0_ be Get(_O_, `"0"`).
+ 1. If _element0_ is *undefined* or *null*, let _R_ be the empty String; otherwise, let _R_ be ? ToString(_element0_).
+ 1. Let _k_ be `1`.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _S_ be the String value produced by concatenating _R_ and _sep_.
+ 1. Let _element_ be ? Get(_O_, ToString(_k_)).
+ 1. If _element_ is *undefined* or *null*, let _next_ be the empty String; otherwise, let _next_ be ? ToString(_element_).
+ 1. Let _R_ be a String value produced by concatenating _S_ and _next_.
+ 1. Increase _k_ by 1.
+ 1. Return _R_.
+
+
+
The `join` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.keys ( )
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Return CreateArrayIterator(_O_, `"key"`).
+
+
+
+
+
+
`lastIndexOf` compares _searchElement_ to the elements of the array in descending order using the Strict Equality Comparison algorithm (), and if found at one or more indices, returns the largest such index; otherwise, -1 is returned.
+
The optional second argument _fromIndex_ defaults to the array's length minus one (i.e. the whole array is searched). If it is greater than or equal to the length of the array, the whole array will be searched. If it is negative, it is used as the offset from the end of the array to compute _fromIndex_. If the computed index is less than 0, -1 is returned.
+
+
When the `lastIndexOf` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If _len_ is 0, return -1.
+ 1. If argument _fromIndex_ was passed, let _n_ be ? ToInteger(_fromIndex_); else let _n_ be _len_-1.
+ 1. If _n_ ≥ 0, let _k_ be min(_n_, _len_ - 1).
+ 1. Else _n_ < 0,
+ 1. Let _k_ be _len_ + _n_.
+ 1. Repeat, while _k_ ≥ 0
+ 1. Let _kPresent_ be ? HasProperty(_O_, ToString(_k_)).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _elementK_ be ? Get(_O_, ToString(_k_)).
+ 1. Let _same_ be the result of performing Strict Equality Comparison _searchElement_ === _elementK_.
+ 1. If _same_ is *true*, return _k_.
+ 1. Decrease _k_ by 1.
+ 1. Return -1.
+
+
The `length` property of the `lastIndexOf` method is 1.
+
+
The `lastIndexOf` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_callbackfn_ should be a function that accepts three arguments. `map` calls _callbackfn_ once for each element in the array, in ascending order, and constructs a new Array from the results. _callbackfn_ is called only for elements of the array which actually exist; it is not called for missing elements of the array.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`map` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
The range of elements processed by `map` is set before the first call to _callbackfn_. Elements which are appended to the array after the call to `map` begins will not be visited by _callbackfn_. If existing elements of the array are changed, their value as passed to _callbackfn_ will be the value at the time `map` visits them; elements that are deleted after the call to `map` begins and before being visited are not visited.
+
+
When the `map` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _A_ be ? ArraySpeciesCreate(_O_, _len_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _mappedValue_ be ? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »).
+ 1. Perform ? CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+ 1. Increase _k_ by 1.
+ 1. Return _A_.
+
+
The `length` property of the `map` method is 1.
+
+
The `map` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.pop ( )
+
+
The last element of the array is removed from the array and returned.
+
+
When the `pop` method is called the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If _len_ is zero, then
+ 1. Perform ? Set(_O_, `"length"`, 0, *true*).
+ 1. Return *undefined*.
+ 1. Else _len_ > 0,
+ 1. Let _newLen_ be _len_-1.
+ 1. Let _indx_ be ToString(_newLen_).
+ 1. Let _element_ be ? Get(_O_, _indx_).
+ 1. Perform ? DeletePropertyOrThrow(_O_, _indx_).
+ 1. Perform ? Set(_O_, `"length"`, _newLen_, *true*).
+ 1. Return _element_.
+
+
+
The `pop` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.push ( ..._items_ )
+
+
The arguments are appended to the end of the array, in the order in which they appear. The new length of the array is returned as the result of the call.
+
+
When the `push` method is called with zero or more arguments the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _items_ be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
+ 1. Let _argCount_ be the number of elements in _items_.
+ 1. If _len_ + _argCount_ > 253-1, throw a *TypeError* exception.
+ 1. Repeat, while _items_ is not empty
+ 1. Remove the first element from _items_ and let _E_ be the value of the element.
+ 1. Perform ? Set(_O_, ToString(_len_), _E_, *true*).
+ 1. Let _len_ be _len_+1.
+ 1. Perform ? Set(_O_, `"length"`, _len_, *true*).
+ 1. Return _len_.
+
+
The `length` property of the `push` method is 1.
+
+
The `push` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_callbackfn_ should be a function that takes four arguments. `reduce` calls the callback, as a function, once for each element present in the array, in ascending order.
+
_callbackfn_ is called with four arguments: the _previousValue_ (value from the previous call to _callbackfn_), the _currentValue_ (value of the current element), the _currentIndex_, and the object being traversed. The first time that callback is called, the _previousValue_ and _currentValue_ can be one of two values. If an _initialValue_ was provided in the call to `reduce`, then _previousValue_ will be equal to _initialValue_ and _currentValue_ will be equal to the first value in the array. If no _initialValue_ was provided, then _previousValue_ will be equal to the first value in the array and _currentValue_ will be equal to the second. It is a *TypeError* if the array contains no elements and _initialValue_ is not provided.
+
`reduce` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
The range of elements processed by `reduce` is set before the first call to _callbackfn_. Elements that are appended to the array after the call to `reduce` begins will not be visited by _callbackfn_. If existing elements of the array are changed, their value as passed to _callbackfn_ will be the value at the time `reduce` visits them; elements that are deleted after the call to `reduce` begins and before being visited are not visited.
+
+
When the `reduce` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _len_ is 0 and _initialValue_ is not present, throw a *TypeError* exception.
+ 1. Let _k_ be 0.
+ 1. If _initialValue_ is present, then
+ 1. Set _accumulator_ to _initialValue_.
+ 1. Else _initialValue_ is not present,
+ 1. Let _kPresent_ be *false*.
+ 1. Repeat, while _kPresent_ is *false* and _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _accumulator_ be ? Get(_O_, _Pk_).
+ 1. Increase _k_ by 1.
+ 1. If _kPresent_ is *false*, throw a *TypeError* exception.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _accumulator_ be ? Call(_callbackfn_, *undefined*, « _accumulator_, _kValue_, _k_, _O_ »).
+ 1. Increase _k_ by 1.
+ 1. Return _accumulator_.
+
+
The `length` property of the `reduce` method is 1.
+
+
The `reduce` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_callbackfn_ should be a function that takes four arguments. `reduceRight` calls the callback, as a function, once for each element present in the array, in descending order.
+
_callbackfn_ is called with four arguments: the _previousValue_ (value from the previous call to _callbackfn_), the _currentValue_ (value of the current element), the _currentIndex_, and the object being traversed. The first time the function is called, the _previousValue_ and _currentValue_ can be one of two values. If an _initialValue_ was provided in the call to `reduceRight`, then _previousValue_ will be equal to _initialValue_ and _currentValue_ will be equal to the last value in the array. If no _initialValue_ was provided, then _previousValue_ will be equal to the last value in the array and _currentValue_ will be equal to the second-to-last value. It is a *TypeError* if the array contains no elements and _initialValue_ is not provided.
+
`reduceRight` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
The range of elements processed by `reduceRight` is set before the first call to _callbackfn_. Elements that are appended to the array after the call to `reduceRight` begins will not be visited by _callbackfn_. If existing elements of the array are changed by _callbackfn_, their value as passed to _callbackfn_ will be the value at the time `reduceRight` visits them; elements that are deleted after the call to `reduceRight` begins and before being visited are not visited.
+
+
When the `reduceRight` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _len_ is 0 and _initialValue_ is not present, throw a *TypeError* exception.
+ 1. Let _k_ be _len_-1.
+ 1. If _initialValue_ is present, then
+ 1. Set _accumulator_ to _initialValue_.
+ 1. Else _initialValue_ is not present,
+ 1. Let _kPresent_ be *false*.
+ 1. Repeat, while _kPresent_ is *false* and _k_ ≥ 0
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _accumulator_ be ? Get(_O_, _Pk_).
+ 1. Decrease _k_ by 1.
+ 1. If _kPresent_ is *false*, throw a *TypeError* exception.
+ 1. Repeat, while _k_ ≥ 0
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _accumulator_ be ? Call(_callbackfn_, *undefined*, « _accumulator_, _kValue_, _k_, _O_ »).
+ 1. Decrease _k_ by 1.
+ 1. Return _accumulator_.
+
+
The `length` property of the `reduceRight` method is 1.
+
+
The `reduceRight` function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.reverse ( )
+
+
The elements of the array are rearranged so as to reverse their order. The object is returned as the result of the call.
+
+
When the `reverse` method is called the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _middle_ be floor(_len_/2).
+ 1. Let _lower_ be 0.
+ 1. Repeat, while _lower_ ≠ _middle_
+ 1. Let _upper_ be _len_- _lower_ -1.
+ 1. Let _upperP_ be ToString(_upper_).
+ 1. Let _lowerP_ be ToString(_lower_).
+ 1. Let _lowerExists_ be ? HasProperty(_O_, _lowerP_).
+ 1. If _lowerExists_ is *true*, then
+ 1. Let _lowerValue_ be ? Get(_O_, _lowerP_).
+ 1. Let _upperExists_ be ? HasProperty(_O_, _upperP_).
+ 1. If _upperExists_ is *true*, then
+ 1. Let _upperValue_ be ? Get(_O_, _upperP_).
+ 1. If _lowerExists_ is *true* and _upperExists_ is *true*, then
+ 1. Perform ? Set(_O_, _lowerP_, _upperValue_, *true*).
+ 1. Perform ? Set(_O_, _upperP_, _lowerValue_, *true*).
+ 1. Else if _lowerExists_ is *false* and _upperExists_ is *true*, then
+ 1. Perform ? Set(_O_, _lowerP_, _upperValue_, *true*).
+ 1. Perform ? DeletePropertyOrThrow(_O_, _upperP_).
+ 1. Else if _lowerExists_ is *true* and _upperExists_ is *false*, then
+ 1. Perform ? DeletePropertyOrThrow(_O_, _lowerP_).
+ 1. Perform ? Set(_O_, _upperP_, _lowerValue_, *true*).
+ 1. Else both _lowerExists_ and _upperExists_ are *false*,
+ 1. No action is required.
+ 1. Increase _lower_ by 1.
+ 1. Return _O_ .
+
+
+
The `reverse` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.shift ( )
+
+
The first element of the array is removed from the array and returned.
+
+
When the `shift` method is called the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If _len_ is zero, then
+ 1. Perform ? Set(_O_, `"length"`, 0, *true*).
+ 1. Return *undefined*.
+ 1. Let _first_ be ? Get(_O_, `"0"`).
+ 1. Let _k_ be 1.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _from_ be ToString(_k_).
+ 1. Let _to_ be ToString(_k_-1).
+ 1. Let _fromPresent_ be ? HasProperty(_O_, _from_).
+ 1. If _fromPresent_ is *true*, then
+ 1. Let _fromVal_ be ? Get(_O_, _from_).
+ 1. Perform ? Set(_O_, _to_, _fromVal_, *true*).
+ 1. Else _fromPresent_ is *false*,
+ 1. Perform ? DeletePropertyOrThrow(_O_, _to_).
+ 1. Increase _k_ by 1.
+ 1. Perform ? DeletePropertyOrThrow(_O_, ToString(_len_-1)).
+ 1. Perform ? Set(_O_, `"length"`, _len_-1, *true*).
+ 1. Return _first_.
+
+
+
The `shift` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.slice (_start_, _end_)
+
+
The `slice` method takes two arguments, _start_ and _end_, and returns an array containing the elements of the array from element _start_ up to, but not including, element _end_ (or through the end of the array if _end_ is *undefined*). If _start_ is negative, it is treated as _length_+_start_ where _length_ is the length of the array. If _end_ is negative, it is treated as _length_+_end_ where _length_ is the length of the array.
+
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _relativeStart_ be ? ToInteger(_start_).
+ 1. If _relativeStart_ < 0, let _k_ be max((_len_ + _relativeStart_),0); else let _k_ be min(_relativeStart_, _len_).
+ 1. If _end_ is *undefined*, let _relativeEnd_ be _len_; else let _relativeEnd_ be ? ToInteger(_end_).
+ 1. If _relativeEnd_ < 0, let _final_ be max((_len_ + _relativeEnd_),0); else let _final_ be min(_relativeEnd_, _len_).
+ 1. Let _count_ be max(_final_ - _k_, 0).
+ 1. Let _A_ be ? ArraySpeciesCreate(_O_, _count_).
+ 1. Let _n_ be 0.
+ 1. Repeat, while _k_ < _final_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _status_ be ? CreateDataPropertyOrThrow(_A_, ToString(_n_), _kValue_ ).
+ 1. Increase _k_ by 1.
+ 1. Increase _n_ by 1.
+ 1. Perform ? Set(_A_, `"length"`, _n_, *true*).
+ 1. Return _A_.
+
+
+
The explicit setting of the `length` property of the result Array in step 11 was necessary in previous editions of ECMAScript to ensure that its length was correct in situations where the trailing elements of the result Array were not present. Setting length became unnecessary starting in ES2015 when the result Array was initialized to its proper length rather than an empty Array but is carried forward to preserve backward compatibility.
+
+
+
The `slice` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
_callbackfn_ should be a function that accepts three arguments and returns a value that is coercible to the Boolean value *true* or *false*. `some` calls _callbackfn_ once for each element present in the array, in ascending order, until it finds one where _callbackfn_ returns *true*. If such an element is found, `some` immediately returns *true*. Otherwise, `some` returns *false*. _callbackfn_ is called only for elements of the array which actually exist; it is not called for missing elements of the array.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the value of the element, the index of the element, and the object being traversed.
+
`some` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
The range of elements processed by `some` is set before the first call to _callbackfn_. Elements that are appended to the array after the call to `some` begins will not be visited by _callbackfn_. If existing elements of the array are changed, their value as passed to _callbackfn_ will be the value at the time that `some` visits them; elements that are deleted after the call to `some` begins and before being visited are not visited. `some` acts like the "exists" quantifier in mathematics. In particular, for an empty array, it returns *false*.
+
+
When the `some` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kPresent_ be ? HasProperty(_O_, _Pk_).
+ 1. If _kPresent_ is *true*, then
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _testResult_ be ToBoolean(? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »)).
+ 1. If _testResult_ is *true*, return *true*.
+ 1. Increase _k_ by 1.
+ 1. Return *false*.
+
+
The `length` property of the `some` method is 1.
+
+
The `some` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.sort (_comparefn_)
+
The elements of this array are sorted. The sort is not necessarily stable (that is, elements that compare equal do not necessarily remain in their original order). If _comparefn_ is not *undefined*, it should be a function that accepts two arguments _x_ and _y_ and returns a negative value if _x_ < _y_, zero if _x_ = _y_, or a positive value if _x_ > _y_.
+
Upon entry, the following steps are performed to initialize evaluation of the `sort` function:
+
+ 1. Let _obj_ be ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_obj_, `"length"`)).
+
+
Within this specification of the `sort` method, an object, _obj_, is said to be sparse if the following algorithm returns *true*:
+
+ 1. For each integer _i_ in the range 0≤_i_< _len_
+ 1. Let _elem_ be _obj_.[[GetOwnProperty]](ToString(_i_)).
+ 1. If _elem_ is *undefined*, return *true*.
+ 1. Return *false*.
+
+
The sort order is the ordering, after completion of this function, of the integer indexed property values of _obj_ whose integer indexes are less than _len_. The result of the `sort` function is then determined as follows:
+
If _comparefn_ is not *undefined* and is not a consistent comparison function for the elements of this array (see below), the sort order is implementation-defined. The sort order is also implementation-defined if _comparefn_ is *undefined* and SortCompare () does not act as a consistent comparison function.
+
Let _proto_ be _obj_.[[GetPrototypeOf]](). If _proto_ is not *null* and there exists an integer _j_ such that all of the conditions below are satisfied then the sort order is implementation-defined:
+
+
+ _obj_ is sparse
+
+
+ 0 ≤ _j_ < _len_
+
+
+ HasProperty(_proto_, ToString(_j_)) is *true*.
+
+
+
The sort order is also implementation defined if _obj_ is sparse and any of the following conditions are true:
+
+
+ IsExtensible(_obj_) is *false*.
+
+
+ Any integer index property of _obj_ whose name is a nonnegative integer less than _len_ is a data property whose [[Configurable]] attribute is *false*.
+
+
+
The sort order is also implementation defined if any of the following conditions are true:
+
+
+ If _obj_ is an exotic object (including Proxy exotic objects) whose behaviour for [[Get]], [[Set]], [[Delete]], and [[GetOwnProperty]] is not the ordinary object implementation of these internal methods.
+
+
+ If any index property of _obj_ whose name is a nonnegative integer less than _len_ is an accessor property or is a data property whose [[Writable]] attribute is *false*.
+
+
+ If _comparefn_ is *undefined* and the application of ToString to any value passed as an argument to SortCompare modifies _obj_ or any object on _obj_'s prototype chain.
+
+
+ If _comparefn_ is *undefined* and all applications of ToString, to any specific value passed as an argument to SortCompare, do not produce the same result.
+
+
+
The following steps are taken:
+
+ 1. Perform an implementation-dependent sequence of calls to the [[Get]] and [[Set]] internal methods of _obj_, to the DeletePropertyOrThrow and HasOwnProperty abstract operation with _obj_ as the first argument, and to SortCompare (described below), such that:
+ * The property key argument for each call to [[Get]], [[Set]], HasOwnProperty, or DeletePropertyOrThrow is the string representation of a nonnegative integer less than _len_.
+ * The arguments for calls to SortCompare are values returned by a previous call to the [[Get]] internal method, unless the properties accessed by those previous calls did not exist according to HasOwnProperty. If both perspective arguments to SortCompare correspond to non-existent properties, use +0 instead of calling SortCompare. If only the first perspective argument is non-existent use +1. If only the second perspective argument is non-existent use -1.
+ * If _obj_ is not sparse then DeletePropertyOrThrow must not be called.
+ * If any [[Set]] call returns *false* a *TypeError* exception is thrown.
+ * If an abrupt completion is returned from any of these operations, it is immediately returned as the value of this function.
+ 1. Return _obj_.
+
+
Unless the sort order is specified above to be implementation-defined, the returned object must have the following two characteristics:
+
+
+ There must be some mathematical permutation π of the nonnegative integers less than _len_, such that for every nonnegative integer _j_ less than _len_, if property old[_j_] existed, then new[π(_j_)] is exactly the same value as old[_j_]. But if property old[_j_] did not exist, then new[π(_j_)] does not exist.
+
+
+ Then for all nonnegative integers _j_ and _k_, each less than _len_, if SortCompare(old[_j_], old[_k_]) < 0 (see SortCompare below), then new[π(_j_)] < new[π(_k_)].
+
+
+
Here the notation old[_j_] is used to refer to the hypothetical result of calling the [[Get]] internal method of _obj_ with argument _j_ before this function is executed, and the notation new[_j_] to refer to the hypothetical result of calling the [[Get]] internal method of _obj_ with argument _j_ after this function has been executed.
+
A function _comparefn_ is a consistent comparison function for a set of values _S_ if all of the requirements below are met for all values _a_, _b_, and _c_ (possibly the same value) in the set _S_: The notation _a_ <CF _b_ means _comparefn_(_a_,_b_) < 0; _a_ =CF _b_ means _comparefn_(_a_,_b_) = 0 (of either sign); and _a_ >CF _b_ means _comparefn_(_a_,_b_) > 0.
+
+
+ Calling _comparefn_(_a_,_b_) always returns the same value _v_ when given a specific pair of values _a_ and _b_ as its two arguments. Furthermore, Type(_v_) is Number, and _v_ is not NaN. Note that this implies that exactly one of _a_ <CF _b_, _a_ =CF _b_, and _a_ >CF _b_ will be true for a given pair of _a_ and _b_.
+
+
+ Calling _comparefn_(_a_,_b_) does not modify _obj_ or any object on _obj_'s prototype chain.
+
+
+ _a_ =CF _a_ (reflexivity)
+
+
+ If _a_ =CF _b_, then _b_ =CF _a_ (symmetry)
+
+
+ If _a_ =CF _b_ and _b_ =CF _c_, then _a_ =CF _c_ (transitivity of =CF)
+
+
+ If _a_ <CF _b_ and _b_ <CF _c_, then _a_ <CF _c_ (transitivity of <CF)
+
+
+ If _a_ >CF _b_ and _b_ >CF _c_, then _a_ >CF _c_ (transitivity of >CF)
+
+
+
+
The above conditions are necessary and sufficient to ensure that _comparefn_ divides the set _S_ into equivalence classes and that these equivalence classes are totally ordered.
+
+
+
The `sort` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore, it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
Runtime Semantics: SortCompare( _x_, _y_ )
+
The SortCompare abstract operation is called with two arguments _x_ and _y_. It also has access to the _comparefn_ argument passed to the current invocation of the `sort` method. The following steps are taken:
+
+ 1. If _x_ and _y_ are both *undefined*, return +0.
+ 1. If _x_ is *undefined*, return 1.
+ 1. If _y_ is *undefined*, return -1.
+ 1. If the argument _comparefn_ is not *undefined*, then
+ 1. Let _v_ be ? ToNumber(? Call(_comparefn_, *undefined*, « _x_, _y_ »)).
+ 1. If _v_ is *NaN*, return +0.
+ 1. Return _v_.
+ 1. Let _xString_ be ? ToString(_x_).
+ 1. Let _yString_ be ? ToString(_y_).
+ 1. If _xString_ < _yString_, return -1.
+ 1. If _xString_ > _yString_, return 1.
+ 1. Return +0.
+
+
+
Because non-existent property values always compare greater than *undefined* property values, and *undefined* always compares greater than any other value, *undefined* property values always sort to the end of the result, followed by non-existent property values.
+
+
+
Method calls performed by the ToString abstract operations in steps 5 and 7 have the potential to cause SortCompare to not behave as a consistent comparison function.
When the `splice` method is called with two or more arguments _start_, _deleteCount_ and zero or more _items_, the _deleteCount_ elements of the array starting at integer index _start_ are replaced by the arguments _items_. An Array object containing the deleted elements (if any) is returned.
+
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _relativeStart_ be ? ToInteger(_start_).
+ 1. If _relativeStart_ < 0, let _actualStart_ be max((_len_ + _relativeStart_),0); else let _actualStart_ be min(_relativeStart_, _len_).
+ 1. If the number of actual arguments is 0, then
+ 1. Let _insertCount_ be 0.
+ 1. Let _actualDeleteCount_ be 0.
+ 1. Else if the number of actual arguments is 1, then
+ 1. Let _insertCount_ be 0.
+ 1. Let _actualDeleteCount_ be _len_ - _actualStart_.
+ 1. Else,
+ 1. Let _insertCount_ be the number of actual arguments minus 2.
+ 1. Let _dc_ be ? ToInteger(_deleteCount_).
+ 1. Let _actualDeleteCount_ be min(max(_dc_,0), _len_ - _actualStart_).
+ 1. If _len_+_insertCount_-_actualDeleteCount_ > 253-1, throw a *TypeError* exception.
+ 1. Let _A_ be ? ArraySpeciesCreate(_O_, _actualDeleteCount_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _actualDeleteCount_
+ 1. Let _from_ be ToString(_actualStart_+_k_).
+ 1. Let _fromPresent_ be ? HasProperty(_O_, _from_).
+ 1. If _fromPresent_ is *true*, then
+ 1. Let _fromValue_ be ? Get(_O_, _from_).
+ 1. Let _status_ be ? CreateDataPropertyOrThrow(_A_, ToString(_k_), _fromValue_).
+ 1. Increment _k_ by 1.
+ 1. Perform ? Set(_A_, `"length"`, _actualDeleteCount_, *true*).
+ 1. Let _items_ be a List whose elements are, in left to right order, the portion of the actual argument list starting with the third argument. The list is empty if fewer than three arguments were passed.
+ 1. Let _itemCount_ be the number of elements in _items_.
+ 1. If _itemCount_ < _actualDeleteCount_, then
+ 1. Let _k_ be _actualStart_.
+ 1. Repeat, while _k_ < (_len_ - _actualDeleteCount_)
+ 1. Let _from_ be ToString(_k_+_actualDeleteCount_).
+ 1. Let _to_ be ToString(_k_+_itemCount_).
+ 1. Let _fromPresent_ be ? HasProperty(_O_, _from_).
+ 1. If _fromPresent_ is *true*, then
+ 1. Let _fromValue_ be ? Get(_O_, _from_).
+ 1. Perform ? Set(_O_, _to_, _fromValue_, *true*).
+ 1. Else _fromPresent_ is *false*,
+ 1. Perform ? DeletePropertyOrThrow(_O_, _to_).
+ 1. Increase _k_ by 1.
+ 1. Let _k_ be _len_.
+ 1. Repeat, while _k_ > (_len_ - _actualDeleteCount_ + _itemCount_)
+ 1. Perform ? DeletePropertyOrThrow(_O_, ToString(_k_-1)).
+ 1. Decrease _k_ by 1.
+ 1. Else if _itemCount_ > _actualDeleteCount_, then
+ 1. Let _k_ be (_len_ - _actualDeleteCount_).
+ 1. Repeat, while _k_ > _actualStart_
+ 1. Let _from_ be ToString(_k_ + _actualDeleteCount_ - 1).
+ 1. Let _to_ be ToString(_k_ + _itemCount_ - 1).
+ 1. Let _fromPresent_ be ? HasProperty(_O_, _from_).
+ 1. If _fromPresent_ is *true*, then
+ 1. Let _fromValue_ be ? Get(_O_, _from_).
+ 1. Perform ? Set(_O_, _to_, _fromValue_, *true*).
+ 1. Else _fromPresent_ is *false*,
+ 1. Perform ? DeletePropertyOrThrow(_O_, _to_).
+ 1. Decrease _k_ by 1.
+ 1. Let _k_ be _actualStart_.
+ 1. Repeat, while _items_ is not empty
+ 1. Remove the first element from _items_ and let _E_ be the value of that element.
+ 1. Perform ? Set(_O_, ToString(_k_), _E_, *true*).
+ 1. Increase _k_ by 1.
+ 1. Perform ? Set(_O_, `"length"`, _len_ - _actualDeleteCount_ + _itemCount_, *true*).
+ 1. Return _A_.
+
+
The `length` property of the `splice` method is 2.
+
+
The explicit setting of the `length` property of the result Array in step 19 was necessary in previous editions of ECMAScript to ensure that its length was correct in situations where the trailing elements of the result Array were not present. Setting `length` became unnecessary starting in ES2015 when the result Array was initialized to its proper length rather than an empty Array but is carried forward to preserve backward compatibility.
+
+
+
The `splice` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `Array.prototype.toLocaleString` method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `toLocaleString` method is used.
+
+
The first edition of ECMA-402 did not include a replacement specification for the `Array.prototype.toLocaleString` method.
+
+
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
+
The following steps are taken:
+
+ 1. Let _array_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_array_, `"length"`)).
+ 1. Let _separator_ be the String value for the list-separator String appropriate for the host environment's current locale (this is derived in an implementation-defined way).
+ 1. If _len_ is zero, return the empty String.
+ 1. Let _firstElement_ be ? Get(_array_, `"0"`).
+ 1. If _firstElement_ is *undefined* or *null*, then
+ 1. Let _R_ be the empty String.
+ 1. Else,
+ 1. Let _R_ be ? ToString(? Invoke(_firstElement_, `"toLocaleString"`)).
+ 1. Let _k_ be `1`.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _S_ be a String value produced by concatenating _R_ and _separator_.
+ 1. Let _nextElement_ be ? Get(_array_, ToString(_k_)).
+ 1. If _nextElement_ is *undefined* or *null*, then
+ 1. Let _R_ be the empty String.
+ 1. Else,
+ 1. Let _R_ be ? ToString(? Invoke(_nextElement_, `"toLocaleString"`)).
+ 1. Let _R_ be a String value produced by concatenating _S_ and _R_.
+ 1. Increase _k_ by 1.
+ 1. Return _R_.
+
+
+
The elements of the array are converted to Strings using their `toLocaleString` methods, and these Strings are then concatenated, separated by occurrences of a separator String that has been derived in an implementation-defined locale-specific way. The result of calling this function is intended to be analogous to the result of `toString`, except that the result of this function is intended to be locale-specific.
+
+
+
The `toLocaleString` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.toString ( )
+
When the `toString` method is called, the following steps are taken:
+
+ 1. Let _array_ be ? ToObject(*this* value).
+ 1. Let _func_ be ? Get(_array_, `"join"`).
+ 1. If IsCallable(_func_) is *false*, let _func_ be the intrinsic function %ObjProto_toString% ().
+ 1. Return Call(_func_, _array_).
+
+
+
The `toString` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.unshift ( ..._items_ )
+
+
The arguments are prepended to the start of the array, such that their order within the array is the same as the order in which they appear in the argument list.
+
+
When the `unshift` method is called with zero or more arguments _item1_, _item2_, etc., the following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Let _len_ be ? ToLength(? Get(_O_, `"length"`)).
+ 1. Let _argCount_ be the number of actual arguments.
+ 1. If _argCount_ > 0, then
+ 1. If _len_+ _argCount_ > 253-1, throw a *TypeError* exception.
+ 1. Let _k_ be _len_.
+ 1. Repeat, while _k_ > 0,
+ 1. Let _from_ be ToString(_k_-1).
+ 1. Let _to_ be ToString(_k_+_argCount_ -1).
+ 1. Let _fromPresent_ be ? HasProperty(_O_, _from_).
+ 1. If _fromPresent_ is *true*, then
+ 1. Let _fromValue_ be ? Get(_O_, _from_).
+ 1. Perform ? Set(_O_, _to_, _fromValue_, *true*).
+ 1. Else _fromPresent_ is *false*,
+ 1. Perform ? DeletePropertyOrThrow(_O_, _to_).
+ 1. Decrease _k_ by 1.
+ 1. Let _j_ be 0.
+ 1. Let _items_ be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
+ 1. Repeat, while _items_ is not empty
+ 1. Remove the first element from _items_ and let _E_ be the value of that element.
+ 1. Perform ? Set(_O_, ToString(_j_), _E_, *true*).
+ 1. Increase _j_ by 1.
+ 1. Perform ? Set(_O_, `"length"`, _len_+_argCount_, *true*).
+ 1. Return _len_+_argCount_.
+
+
The `length` property of the `unshift` method is 1.
+
+
The `unshift` function is intentionally generic; it does not require that its *this* value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
Array.prototype.values ( )
+
The following steps are taken:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Return CreateArrayIterator(_O_, `"value"`).
+
+
This function is the %ArrayProto_values% intrinsic object.
+
+
+
+
+
Array.prototype [ @@iterator ] ( )
+
The initial value of the @@iterator property is the same function object as the initial value of the `Array.prototype.values` property.
+
+
+
+
+
Array.prototype [ @@unscopables ]
+
The initial value of the @@unscopables data property is an object created by the following steps:
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
The own property names of this object are property names that were not included as standard properties of `Array.prototype` prior to the ECMAScript 2015 specification. These names are ignored for `with` statement binding purposes in order to preserve the behaviour of existing code that might use one of these names as a binding in an outer scope that is shadowed by a `with` statement whose binding object is an Array object.
+
+
+
+
+
+
+
Properties of Array Instances
+
Array instances are Array exotic objects and have the internal methods specified for such objects. Array instances inherit properties from the Array prototype object.
+
Array instances have a `length` property, and a set of enumerable properties with array index names.
+
+
+
+
length
+
The `length` property of an Array instance is a data property whose value is always numerically greater than the name of every configurable own property whose name is an array index.
+
The `length` property initially has the attributes { [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
Reducing the value of the `length` property has the side-effect of deleting own array elements whose array index is between the old and new length values. However, non-configurable properties can not be deleted. Attempting to set the length property of an Array object to a value that is numerically less than or equal to the largest numeric own property name of an existing non-configurable array indexed property of the array will result in the length being set to a numeric value that is one greater than that non-configurable numeric own property name. See .
+
+
+
+
+
+
+
Array Iterator Objects
+
An Array Iterator is an object, that represents a specific iteration over some specific Array instance object. There is not a named constructor for Array Iterator objects. Instead, Array iterator objects are created by calling certain methods of Array instance objects.
+
+
+
+
CreateArrayIterator Abstract Operation
+
Several methods of Array objects return Iterator objects. The abstract operation CreateArrayIterator with arguments _array_ and _kind_ is used to create such iterator objects. It performs the following steps:
+
+ 1. Assert: Type(_array_) is Object.
+ 1. Let _iterator_ be ObjectCreate(%ArrayIteratorPrototype%, « [[IteratedObject]], [[ArrayIteratorNextIndex]], [[ArrayIterationKind]] »).
+ 1. Set _iterator_'s [[IteratedObject]] internal slot to _array_.
+ 1. Set _iterator_'s [[ArrayIteratorNextIndex]] internal slot to 0.
+ 1. Set _iterator_'s [[ArrayIterationKind]] internal slot to _kind_.
+ 1. Return _iterator_.
+
+
+
+
+
+
The %ArrayIteratorPrototype% Object
+
All Array Iterator Objects inherit properties from the %ArrayIteratorPrototype% intrinsic object. The %ArrayIteratorPrototype% object is an ordinary object and its [[Prototype]] internal slot is the %IteratorPrototype% intrinsic object (). In addition, %ArrayIteratorPrototype% has the following properties:
+
+
+
+
%ArrayIteratorPrototype%.next( )
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have all of the internal slots of an Array Iterator Instance (), throw a *TypeError* exception.
+ 1. Let _a_ be the value of the [[IteratedObject]] internal slot of _O_.
+ 1. If _a_ is *undefined*, return CreateIterResultObject(*undefined*, *true*).
+ 1. Let _index_ be the value of the [[ArrayIteratorNextIndex]] internal slot of _O_.
+ 1. Let _itemKind_ be the value of the [[ArrayIterationKind]] internal slot of _O_.
+ 1. If _a_ has a [[TypedArrayName]] internal slot, then
+ 1. Let _len_ be the value of _a_'s [[ArrayLength]] internal slot.
+ 1. Else,
+ 1. Let _len_ be ? ToLength(? Get(_a_, `"length"`)).
+ 1. If _index_ ≥ _len_, then
+ 1. Set the value of the [[IteratedObject]] internal slot of _O_ to *undefined*.
+ 1. Return CreateIterResultObject(*undefined*, *true*).
+ 1. Set the value of the [[ArrayIteratorNextIndex]] internal slot of _O_ to _index_+1.
+ 1. If _itemKind_ is `"key"`, return CreateIterResultObject(_index_, *false*).
+ 1. Let _elementKey_ be ToString(_index_).
+ 1. Let _elementValue_ be ? Get(_a_, _elementKey_).
+ 1. If _itemKind_ is `"value"`, let _result_ be _elementValue_.
+ 1. Else,
+ 1. Assert: _itemKind_ is `"key+value"`.
+ 1. Let _result_ be CreateArrayFromList(« _index_, _elementValue_ »).
+ 1. Return CreateIterResultObject(_result_, *false*).
+
+
+
+
+
+
%ArrayIteratorPrototype% [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Array Iterator"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Array Iterator Instances
+
Array Iterator instances are ordinary objects that inherit properties from the %ArrayIteratorPrototype% intrinsic object. Array Iterator instances are initially created with the internal slots listed in .
+
+
+
+
+
+ Internal Slot
+
+
+ Description
+
+
+
+
+ [[IteratedObject]]
+
+
+ The object whose array elements are being iterated.
+
+
+
+
+ [[ArrayIteratorNextIndex]]
+
+
+ The integer index of the next integer index to be examined by this iteration.
+
+
+
+
+ [[ArrayIterationKind]]
+
+
+ A String value that identifies what is returned for each element of the iteration. The possible values are: `"key"`, `"value"`, `"key+value"`.
+
+
+
+
+
+
+
+
+
+
+
+
TypedArray Objects
+
_TypedArray_ objects present an array-like view of an underlying binary data buffer (). Each element of a _TypedArray_ instance has the same underlying binary scalar data type. There is a distinct _TypedArray_ constructor, listed in , for each of the nine supported element types. Each constructor in has a corresponding distinct prototype object.
+
+
+
+
+
+ Constructor Name and Intrinsic
+
+
+ Element Type
+
+
+ Element Size
+
+
+ Conversion Operation
+
+
+ Description
+
+
+ Equivalent C Type
+
+
+
+
+ Int8Array
+
+ %Int8Array%
+
+
+ Int8
+
+
+ 1
+
+
+ ToInt8
+
+
+ 8-bit 2's complement signed integer
+
+
+ signed char
+
+
+
+
+ Uint8Array
+
+ %Uint8Array%
+
+
+ Uint8
+
+
+ 1
+
+
+ ToUint8
+
+
+ 8-bit unsigned integer
+
+
+ unsigned char
+
+
+
+
+ Uint8ClampedArray
+
+ %Uint8ClampedArray%
+
+
+ Uint8C
+
+
+ 1
+
+
+ ToUint8Clamp
+
+
+ 8-bit unsigned integer (clamped conversion)
+
+
+ unsigned char
+
+
+
+
+ Int16Array
+
+ %Int16Array%
+
+
+ Int16
+
+
+ 2
+
+
+ ToInt16
+
+
+ 16-bit 2's complement signed integer
+
+
+ short
+
+
+
+
+ Uint16Array
+
+ %Uint16Array%
+
+
+ Uint16
+
+
+ 2
+
+
+ ToUint16
+
+
+ 16-bit unsigned integer
+
+
+ unsigned short
+
+
+
+
+ Int32Array
+
+ %Int32Array%
+
+
+ Int32
+
+
+ 4
+
+
+ ToInt32
+
+
+ 32-bit 2's complement signed integer
+
+
+ int
+
+
+
+
+ Uint32Array
+
+ %Uint32Array%
+
+
+ Uint32
+
+
+ 4
+
+
+ ToUint32
+
+
+ 32-bit unsigned integer
+
+
+ unsigned int
+
+
+
+
+ Float32Array
+
+ %Float32Array%
+
+
+ Float32
+
+
+ 4
+
+
+
+
+ 32-bit IEEE floating point
+
+
+ float
+
+
+
+
+ Float64Array
+
+ %Float64Array%
+
+
+ Float64
+
+
+ 8
+
+
+
+
+ 64-bit IEEE floating point
+
+
+ double
+
+
+
+
+
+
In the definitions below, references to _TypedArray_ should be replaced with the appropriate constructor name from the above table. The phrase “the element size in bytes” refers to the value in the Element Size column of the table in the row corresponding to the constructor. The phrase “element Type” refers to the value in the Element Type column for that row.
+
+
+
+
The %TypedArray% Intrinsic Object
+
The %TypedArray% intrinsic object is a constructor function object that all of the _TypedArray_ constructor object inherit from. %TypedArray% and its corresponding prototype object provide common properties that are inherited by all _TypedArray_ constructors and their instances. The %TypedArray% intrinsic does not have a global name or appear as a property of the global object.
+
The %TypedArray% intrinsic function object is designed to act as the superclass of the various _TypedArray_ constructors. Those constructors use %TypedArray% to initialize their instances by invoking %TypedArray% as if by making a `super` call. The %TypedArray% intrinsic function is not designed to be directly called in any other way. If %TypedArray% is directly called or called as part of a `new` expression an exception is thrown.
+
The %TypedArray% intrinsic constructor function is a single function whose behaviour is overloaded based upon the number and types of its arguments. The actual behaviour of a `super` call of %TypedArray% depends upon the number and kind of arguments that are passed to it.
+
+
+
+
%TypedArray% ( )
+
This description applies only if the %TypedArray% function is called with no arguments.
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Return AllocateTypedArray(NewTarget, 0).
+
+
+
+
+
+
%TypedArray% ( _length_ )
+
This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is not Object.
+
%TypedArray% called with argument _length_ performs the following steps:
+
+ 1. Assert: Type(_length_) is not Object.
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. If _length_ is *undefined*, throw a *TypeError* exception.
+ 1. Let _numberLength_ be ToNumber(_length_).
+ 1. Let _elementLength_ be ? ToLength(_numberLength_).
+ 1. If SameValueZero(_numberLength_, _elementLength_) is *false*, throw a *RangeError* exception.
+ 1. Return AllocateTypedArray(NewTarget, _elementLength_).
+
+
+
+
+
The abstract operation AllocateTypedArray with argument _newTarget_ and optional argument _length_ is used to validate and create an instance of a TypedArray constructor. If the _length_ argument is passed an ArrayBuffer of that length is also allocated and associated with the new TypedArray instance. AllocateTypedArray provides common semantics that is used by all of the %TypeArray% overloads and other methods. AllocateTypedArray performs the following steps:
+
+ 1. Assert: IsConstructor(_newTarget_) is *true*.
+ 1. If SameValue(%TypedArray%, _newTarget_) is *true*, throw a *TypeError* exception.
+ 1. NOTE %TypedArray% throws an exception when invoked via either a function call or the `new` operator. It can only be successfully invoked by a |SuperCall|.
+ 1. Let _constructorName_ be *undefined*.
+ 1. Let _subclass_ be _newTarget_.
+ 1. Repeat while _constructorName_ is *undefined*
+ 1. If _subclass_ is *null*, throw a *TypeError* exception.
+ 1. If SameValue(%TypedArray%, _subclass_) is *true*, throw a *TypeError* exception.
+ 1. If _subclass_ has a [[TypedArrayConstructorName]] internal slot, let _constructorName_ be the value of _subclass_'s [[TypedArrayConstructorName]] internal slot.
+ 1. Let _subclass_ be ? _subclass_.[[GetPrototypeOf]]().
+ 1. Let _proto_ be ? GetPrototypeFromConstructor(_newTarget_, `"%TypedArrayPrototype%"`).
+ 1. Let _obj_ be IntegerIndexedObjectCreate(_proto_, « [[ViewedArrayBuffer]], [[TypedArrayName]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] » ).
+ 1. Assert: The [[ViewedArrayBuffer]] internal slot of _obj_ is *undefined*.
+ 1. Set _obj_'s [[TypedArrayName]] internal slot to _constructorName_.
+ 1. If _length_ was not passed, then
+ 1. Set _obj_'s [[ByteLength]] internal slot to 0.
+ 1. Set _obj_'s [[ByteOffset]] internal slot to 0.
+ 1. Set _obj_'s [[ArrayLength]] internal slot to 0.
+ 1. Else,
+ 1. Let _elementSize_ be the Element Size value in for _constructorName_.
+ 1. Let _byteLength_ be _elementSize_ × _length_.
+ 1. Let _data_ be ? AllocateArrayBuffer(%ArrayBuffer%, _byteLength_).
+ 1. Set _obj_'s [[ViewedArrayBuffer]] internal slot to _data_.
+ 1. Set _obj_'s [[ByteLength]] internal slot to _byteLength_.
+ 1. Set _obj_'s [[ByteOffset]] internal slot to 0.
+ 1. Set _obj_'s [[ArrayLength]] internal slot to _length_.
+ 1. Return _obj_.
+
+
+
+
+
+
+
%TypedArray% ( _typedArray_ )
+
This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is Object and that object has a [[TypedArrayName]] internal slot.
+
%TypedArray% called with argument _typedArray_ performs the following steps:
+
+ 1. Assert: Type(_typedArray_) is Object and _typedArray_ has a [[TypedArrayName]] internal slot.
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _O_ be ? AllocateTypedArray(NewTarget).
+ 1. Let _srcArray_ be _typedArray_.
+ 1. Let _srcData_ be the value of _srcArray_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_srcData_) is *true*, throw a *TypeError* exception.
+ 1. Let _constructorName_ be the String value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _elementType_ be the String value of the Element Type value in for _constructorName_.
+ 1. Let _elementLength_ be the value of _srcArray_'s [[ArrayLength]] internal slot.
+ 1. Let _srcName_ be the String value of _srcArray_'s [[TypedArrayName]] internal slot.
+ 1. Let _srcType_ be the String value of the Element Type value in for _srcName_.
+ 1. Let _srcElementSize_ be the Element Size value in for _srcName_.
+ 1. Let _srcByteOffset_ be the value of _srcArray_'s [[ByteOffset]] internal slot.
+ 1. Let _elementSize_ be the Element Size value in for _constructorName_.
+ 1. Let _byteLength_ be _elementSize_ × _elementLength_.
+ 1. If SameValue(_elementType_,_srcType_) is *true*, then
+ 1. Let _data_ be ? CloneArrayBuffer(_srcData_, _srcByteOffset_).
+ 1. Else,
+ 1. Let _bufferConstructor_ be ? SpeciesConstructor(_srcData_, %ArrayBuffer%).
+ 1. Let _data_ be ? AllocateArrayBuffer(_bufferConstructor_, _byteLength_).
+ 1. If IsDetachedBuffer(_srcData_) is *true*, throw a *TypeError* exception.
+ 1. Let _srcByteIndex_ be _srcByteOffset_.
+ 1. Let _targetByteIndex_ be 0.
+ 1. Let _count_ be _elementLength_.
+ 1. Repeat, while _count_ >0
+ 1. Let _value_ be GetValueFromBuffer(_srcData_, _srcByteIndex_, _srcType_).
+ 1. Perform SetValueInBuffer(_data_, _targetByteIndex_, _elementType_, _value_).
+ 1. Set _srcByteIndex_ to _srcByteIndex_ + _srcElementSize_.
+ 1. Set _targetByteIndex_ to _targetByteIndex_ + _elementSize_.
+ 1. Decrement _count_ by 1.
+ 1. Set _O_'s [[ViewedArrayBuffer]] internal slot to _data_.
+ 1. Set _O_'s [[ByteLength]] internal slot to _byteLength_.
+ 1. Set _O_'s [[ByteOffset]] internal slot to 0.
+ 1. Set _O_'s [[ArrayLength]] internal slot to _elementLength_.
+ 1. Return _O_.
+
+
+
+
+
+
%TypedArray% ( _object_ )
+
This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is Object and that object does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] internal slot.
+
%TypedArray% called with argument _object_ performs the following steps:
+
+ 1. Assert: Type(_object_) is Object and _object_ does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] internal slot.
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Return TypedArrayFrom(NewTarget, _object_, *undefined*, *undefined*).
+
+
+
+
+
+
This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is Object and that object has an [[ArrayBufferData]] internal slot.
+
%TypedArray% called with arguments _buffer_, _byteOffset_, and _length_ performs the following steps:
+
+ 1. Assert: Type(_buffer_) is Object and _buffer_ has an [[ArrayBufferData]] internal slot.
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _O_ be ? AllocateTypedArray(NewTarget).
+ 1. Let _constructorName_ be the String value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value in for _constructorName_.
+ 1. Let _offset_ be ? ToInteger(_byteOffset_).
+ 1. If _offset_ < 0, throw a *RangeError* exception.
+ 1. If _offset_ is -0, let _offset_ be +0.
+ 1. If _offset_ modulo _elementSize_ ≠ 0, throw a *RangeError* exception.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _bufferByteLength_ be the value of _buffer_'s [[ArrayBufferByteLength]] internal slot.
+ 1. If _length_ is *undefined*, then
+ 1. If _bufferByteLength_ modulo _elementSize_ ≠ 0, throw a *RangeError* exception.
+ 1. Let _newByteLength_ be _bufferByteLength_ - _offset_.
+ 1. If _newByteLength_ < 0, throw a *RangeError* exception.
+ 1. Else,
+ 1. Let _newLength_ be ? ToLength(_length_).
+ 1. Let _newByteLength_ be _newLength_ × _elementSize_.
+ 1. If _offset_+_newByteLength_ > _bufferByteLength_, throw a *RangeError* exception.
+ 1. Set _O_'s [[ViewedArrayBuffer]] internal slot to _buffer_.
+ 1. Set _O_'s [[ByteLength]] internal slot to _newByteLength_.
+ 1. Set _O_'s [[ByteOffset]] internal slot to _offset_.
+ 1. Set _O_'s [[ArrayLength]] internal slot to _newByteLength_ / _elementSize_ .
+ 1. Return _O_.
+
+
+
+
+
+
+
Properties of the %TypedArray% Intrinsic Object
+
The value of the [[Prototype]] internal slot of %TypedArray% is the intrinsic object %FunctionPrototype% ().
+
Besides a `length` property whose value is 3 and a `name` property whose value is `"TypedArray"`, %TypedArray% has the following properties:
When the `from` method is called with argument _source_, and optional arguments _mapfn_ and _thisArg_, the following steps are taken:
+
+ 1. Let _C_ be the *this* value.
+ 1. If IsConstructor(_C_) is *false*, throw a *TypeError* exception.
+ 1. If _mapfn_ was supplied, let _f_ be _mapfn_; otherwise let _f_ be *undefined*.
+ 1. If _f_ is not *undefined*, then
+ 1. If IsCallable(_f_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _t_ be _thisArg_; else let _t_ be *undefined*.
+ 1. Return TypedArrayFrom(_C_, _source_, _f_, _t_).
+
+
When the TypedArrayFrom abstract operation is called with arguments _constructor_, _items_, _mapfn_, and _thisArg_, the following steps are taken:
+
+ 1. Let _C_ be _constructor_.
+ 1. Assert: IsConstructor(_C_) is *true*.
+ 1. Assert: _mapfn_ is either a callable Object or *undefined*.
+ 1. If _mapfn_ is *undefined*, let _mapping_ be *false*.
+ 1. Else,
+ 1. Let _T_ be _thisArg_.
+ 1. Let _mapping_ be *true*.
+ 1. Let _usingIterator_ be ? GetMethod(_items_, @@iterator).
+ 1. If _usingIterator_ is not *undefined*, then
+ 1. Let _iterator_ be ? GetIterator(_items_, _usingIterator_).
+ 1. Let _values_ be a new empty List.
+ 1. Let _next_ be *true*.
+ 1. Repeat, while _next_ is not *false*
+ 1. Let _next_ be ? IteratorStep(_iterator_).
+ 1. If _next_ is not *false*, then
+ 1. Let _nextValue_ be ? IteratorValue(_next_).
+ 1. Append _nextValue_ to the end of the List _values_.
+ 1. Let _len_ be the number of elements in _values_.
+ 1. Let _targetObj_ be ? AllocateTypedArray(_C_, _len_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be the first element of _values_ and remove that element from _values_.
+ 1. If _mapping_ is *true*, then
+ 1. Let _mappedValue_ be ? Call(_mapfn_, _T_, « _kValue_, _k_ »).
+ 1. Else, let _mappedValue_ be _kValue_.
+ 1. Perform ? Set(_targetObj_, _Pk_, _mappedValue_, *true*).
+ 1. Increase _k_ by 1.
+ 1. Assert: _values_ is now an empty List.
+ 1. Return _targetObj_.
+ 1. Assert: _items_ is not an Iterable so assume it is an array-like object.
+ 1. Let _arrayLike_ be ? ToObject(_items_).
+ 1. Let _len_ be ? ToLength(? Get(_arrayLike_, `"length"`)).
+ 1. Let _targetObj_ be ? AllocateTypedArray(_C_, _len_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_arrayLike_, _Pk_).
+ 1. If _mapping_ is *true*, then
+ 1. Let _mappedValue_ be ? Call(_mapfn_, _T_, « _kValue_, _k_ »).
+ 1. Else, let _mappedValue_ be _kValue_.
+ 1. Perform ? Set(_targetObj_, _Pk_, _mappedValue_, *true*).
+ 1. Increase _k_ by 1.
+ 1. Return _targetObj_.
+
+
+
+
+
+
+
%TypedArray%.of ( ..._items_ )
+
When the `of` method is called with any number of arguments, the following steps are taken:
+
+ 1. Let _len_ be the actual number of arguments passed to this function.
+ 1. Let _items_ be the List of arguments passed to this function.
+ 1. Let _C_ be the *this* value.
+ 1. If IsConstructor(_C_) is *false*, throw a *TypeError* exception.
+ 1. Let _newObj_ be ? AllocateTypedArray(_C_, _len_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _kValue_ be _items_[_k_].
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _status_ be ? Set(_newObj_, _Pk_, _kValue_, *true*).
+ 1. Increase _k_ by 1.
+ 1. Return _newObj_.
+
+
The `length` property of the `of` method is 0.
+
+
The _items_ argument is assumed to be a well-formed rest argument value.
+
+
+
+
+
+
%TypedArray%.prototype
+
The initial value of %TypedArray%.prototype is the %TypedArrayPrototype% intrinsic object ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
get %TypedArray% [ @@species ]
+
%TypedArray%[@@species] is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
%TypedArrayPrototype% methods normally use their `this` object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.
+
+
+
+
+
+
+
Properties of the %TypedArrayPrototype% Object
+
The value of the [[Prototype]] internal slot of the %TypedArrayPrototype% object is the intrinsic object %ObjectPrototype% (). The %TypedArrayPrototype% object is an ordinary object. It does not have a [[ViewedArrayBuffer]] or any other of the internal slots that are specific to _TypedArray_ instance objects.
+
+
+
+
get %TypedArray%.prototype.buffer
+
%TypedArray%.`prototype.buffer` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. Return _buffer_.
+
+
+
+
+
+
get %TypedArray%.prototype.byteLength
+
%TypedArray%.`prototype.byteLength` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, return 0.
+ 1. Let _size_ be the value of _O_'s [[ByteLength]] internal slot.
+ 1. Return _size_.
+
+
+
+
+
+
get %TypedArray%.prototype.byteOffset
+
%TypedArray%.`prototype.byteOffset` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, return 0.
+ 1. Let _offset_ be the value of _O_'s [[ByteOffset]] internal slot.
+ 1. Return _offset_.
+
+
+
+
+
+
%TypedArray%.prototype.constructor
+
The initial value of %TypedArray%.prototype.constructor is the %TypedArray% intrinsic object.
%TypedArray%`.prototype.copyWithin` is a distinct function that implements the same algorithm as `Array.prototype.copyWithin` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"` and the actual copying of values in step 12 must be performed in a manner that preserves the bit-level encoding of the source data
+
The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `copyWithin` method is 2.
+
+
+
+
Runtime Semantics: ValidateTypedArray ( _O_ )
+
When called with argument _O_ the following steps are taken:
+
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[TypedArrayName]] internal slot, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Return _buffer_.
+
+
+
+
+
+
+
%TypedArray%.prototype.entries ( )
+
The following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _valid_ be ? ValidateTypedArray(_O_).
+ 1. Return CreateArrayIterator(_O_, `"key+value"`).
+
+
+
+
+
+
%TypedArray%`.prototype.every` is a distinct function that implements the same algorithm as `Array.prototype.every` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _callbackfn_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
%TypedArray%`.prototype.fill` is a distinct function that implements the same algorithm as `Array.prototype.fill` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
The interpretation and use of the arguments of %TypedArray%`.prototype.filter` are the same as for `Array.prototype.filter` as defined in .
+
When the `filter` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _valid_ be ? ValidateTypedArray(_O_).
+ 1. Let _len_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _defaultConstructor_ be the intrinsic object listed in column one of for the value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _C_ be ? SpeciesConstructor(_O_, _defaultConstructor_).
+ 1. Let _kept_ be a new empty List.
+ 1. Let _k_ be 0.
+ 1. Let _captured_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _selected_ be ToBoolean(? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »)).
+ 1. If _selected_ is *true*, then
+ 1. Append _kValue_ to the end of _kept_.
+ 1. Increase _captured_ by 1.
+ 1. Increase _k_ by 1.
+ 1. Let _A_ be ? AllocateTypedArray(_C_, _captured_).
+ 1. Let _n_ be 0.
+ 1. For each element _e_ of _kept_
+ 1. Let _status_ be ? Set(_A_, ToString(_n_), _e_, *true* ).
+ 1. Increment _n_ by 1.
+ 1. Return _A_.
+
+
This function is not generic. The *this* value must be an object with a [[TypedArrayName]] internal slot.
+
The `length` property of the `filter` method is 1.
%TypedArray%`.prototype.find` is a distinct function that implements the same algorithm as `Array.prototype.find` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _predicate_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
%TypedArray%`.prototype.findIndex` is a distinct function that implements the same algorithm as `Array.prototype.findIndex` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _predicate_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `findIndex` method is 1.
%TypedArray%`.prototype.forEach` is a distinct function that implements the same algorithm as `Array.prototype.forEach` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _callbackfn_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `forEach` method is 1.
%TypedArray%`.prototype.indexOf` is a distinct function that implements the same algorithm as `Array.prototype.indexOf` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `indexOf` method is 1.
`%TypedArray%.prototype.includes` is a distinct function that implements the same algorithm as `Array.prototype.includes` as defined in except that the *this* object’s [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
+
The `length` property of the `includes` method is *1*.
+
+
+
+
+
%TypedArray%.prototype.join ( _separator_ )
+
%TypedArray%`.prototype.join` is a distinct function that implements the same algorithm as `Array.prototype.join` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
+
+
+
+
%TypedArray%.prototype.keys ( )
+
The following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _valid_ be ? ValidateTypedArray(_O_).
+ 1. Return CreateArrayIterator(_O_, `"key"`).
+
+
+
+
+
+
%TypedArray%`.prototype.lastIndexOf` is a distinct function that implements the same algorithm as `Array.prototype.lastIndexOf` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `lastIndexOf` method is 1.
+
+
+
+
+
get %TypedArray%.prototype.length
+
%TypedArray%.`prototype.length` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[TypedArrayName]] internal slot, throw a *TypeError* exception.
+ 1. Assert: _O_ has [[ViewedArrayBuffer]] and [[ArrayLength]] internal slots.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, return 0.
+ 1. Let _length_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. Return _length_.
+
+
This function is not generic. The *this* value must be an object with a [[TypedArrayName]] internal slot.
The interpretation and use of the arguments of %TypedArray%`.prototype.map` are the same as for `Array.prototype.map` as defined in .
+
When the `map` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _valid_ be ? ValidateTypedArray(_O_).
+ 1. Let _len_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _defaultConstructor_ be the intrinsic object listed in column one of for the value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _C_ be ? SpeciesConstructor(_O_, _defaultConstructor_).
+ 1. Let _A_ be ? AllocateTypedArray(_C_, _len_).
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _len_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _mappedValue_ be ? Call(_callbackfn_, _T_, « _kValue_, _k_, _O_ »).
+ 1. Let _status_ be ? Set(_A_, _Pk_, _mappedValue_, *true* ).
+ 1. Increase _k_ by 1.
+ 1. Return _A_.
+
+
This function is not generic. The *this* value must be an object with a [[TypedArrayName]] internal slot.
%TypedArray%`.prototype.reduce` is a distinct function that implements the same algorithm as `Array.prototype.reduce` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _callbackfn_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `reduce` method is 1.
%TypedArray%`.prototype.reduceRight` is a distinct function that implements the same algorithm as `Array.prototype.reduceRight` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _callbackfn_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `reduceRight` method is 1.
+
+
+
+
+
%TypedArray%.prototype.reverse ( )
+
%TypedArray%`.prototype.reverse` is a distinct function that implements the same algorithm as `Array.prototype.reverse` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
Sets multiple values in this _TypedArray_, reading the values from the object _array_. The optional _offset_ value indicates the first element index in this _TypedArray_ where values are written. If omitted, it is assumed to be 0.
+
+ 1. Assert: _array_ is any ECMAScript language value other than an Object with a [[TypedArrayName]] internal slot. If it is such an Object, the definition in applies.
+ 1. Let _target_ be the *this* value.
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. If _target_ does not have a [[TypedArrayName]] internal slot, throw a *TypeError* exception.
+ 1. Assert: _target_ has a [[ViewedArrayBuffer]] internal slot.
+ 1. Let _targetOffset_ be ? ToInteger(_offset_).
+ 1. If _targetOffset_ < 0, throw a *RangeError* exception.
+ 1. Let _targetBuffer_ be the value of _target_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_targetBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _targetLength_ be the value of _target_'s [[ArrayLength]] internal slot.
+ 1. Let _targetName_ be the String value of _target_'s [[TypedArrayName]] internal slot.
+ 1. Let _targetElementSize_ be the Number value of the Element Size value specified in for _targetName_.
+ 1. Let _targetType_ be the String value of the Element Type value in for _targetName_.
+ 1. Let _targetByteOffset_ be the value of _target_'s [[ByteOffset]] internal slot.
+ 1. Let _src_ be ? ToObject(_array_).
+ 1. Let _srcLength_ be ? ToLength(? Get(_src_, `"length"`)).
+ 1. If _srcLength_ + _targetOffset_ > _targetLength_, throw a *RangeError* exception.
+ 1. Let _targetByteIndex_ be _targetOffset_ × _targetElementSize_ + _targetByteOffset_.
+ 1. Let _k_ be 0.
+ 1. Let _limit_ be _targetByteIndex_ + _targetElementSize_ × _srcLength_.
+ 1. Repeat, while _targetByteIndex_ < _limit_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kNumber_ be ? ToNumber(? Get(_src_, _Pk_)).
+ 1. If IsDetachedBuffer(_targetBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Perform SetValueInBuffer(_targetBuffer_, _targetByteIndex_, _targetType_, _kNumber_).
+ 1. Set _k_ to _k_ + 1.
+ 1. Set _targetByteIndex_ to _targetByteIndex_ + _targetElementSize_.
+ 1. Return *undefined*.
+
+
+
+
+
+
Sets multiple values in this _TypedArray_, reading the values from the _typedArray_ argument object. The optional _offset_ value indicates the first element index in this _TypedArray_ where values are written. If omitted, it is assumed to be 0.
+
+ 1. Assert: _typedArray_ has a [[TypedArrayName]] internal slot. If it does not, the definition in applies.
+ 1. Let _target_ be the *this* value.
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. If _target_ does not have a [[TypedArrayName]] internal slot, throw a *TypeError* exception.
+ 1. Assert: _target_ has a [[ViewedArrayBuffer]] internal slot.
+ 1. Let _targetOffset_ be ? ToInteger(_offset_).
+ 1. If _targetOffset_ < 0, throw a *RangeError* exception.
+ 1. Let _targetBuffer_ be the value of _target_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_targetBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _targetLength_ be the value of _target_'s [[ArrayLength]] internal slot.
+ 1. Let _srcBuffer_ be the value of _typedArray_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_srcBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _targetName_ be the String value of _target_'s [[TypedArrayName]] internal slot.
+ 1. Let _targetType_ be the String value of the Element Type value in for _targetName_.
+ 1. Let _targetElementSize_ be the Number value of the Element Size value specified in for _targetName_.
+ 1. Let _targetByteOffset_ be the value of _target_'s [[ByteOffset]] internal slot.
+ 1. Let _srcName_ be the String value of _typedArray_'s [[TypedArrayName]] internal slot.
+ 1. Let _srcType_ be the String value of the Element Type value in for _srcName_ .
+ 1. Let _srcElementSize_ be the Number value of the Element Size value specified in for _srcName_.
+ 1. Let _srcLength_ be the value of _typedArray_'s [[ArrayLength]] internal slot.
+ 1. Let _srcByteOffset_ be the value of _typedArray_'s [[ByteOffset]] internal slot.
+ 1. If _srcLength_ + _targetOffset_ > _targetLength_, throw a *RangeError* exception.
+ 1. If SameValue(_srcBuffer_, _targetBuffer_) is *true*, then
+ 1. Let _srcBuffer_ be ? CloneArrayBuffer(_targetBuffer_, _srcByteOffset_, %ArrayBuffer%).
+ 1. NOTE: %ArrayBuffer% is used to clone _targetBuffer_ because is it known to not have any observable side-effects.
+ 1. Let _srcByteIndex_ be 0.
+ 1. Else, let _srcByteIndex_ be _srcByteOffset_.
+ 1. Let _targetByteIndex_ be _targetOffset_ × _targetElementSize_ + _targetByteOffset_.
+ 1. Let _limit_ be _targetByteIndex_ + _targetElementSize_ × _srcLength_.
+ 1. If SameValue(_srcType_, _targetType_) is *false*, then
+ 1. Repeat, while _targetByteIndex_ < _limit_
+ 1. Let _value_ be GetValueFromBuffer(_srcBuffer_, _srcByteIndex_, _srcType_).
+ 1. Perform SetValueInBuffer(_targetBuffer_, _targetByteIndex_, _targetType_, _value_).
+ 1. Set _srcByteIndex_ to _srcByteIndex_ + _srcElementSize_.
+ 1. Set _targetByteIndex_ to _targetByteIndex_ + _targetElementSize_.
+ 1. Else,
+ 1. NOTE: If _srcType_ and _targetType_ are the same the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
+ 1. Repeat, while _targetByteIndex_ < _limit_
+ 1. Let _value_ be GetValueFromBuffer(_srcBuffer_, _srcByteIndex_, `"Uint8"`).
+ 1. Perform SetValueInBuffer(_targetBuffer_, _targetByteIndex_, `"Uint8"`, _value_).
+ 1. Set _srcByteIndex_ to _srcByteIndex_ + 1.
+ 1. Set _targetByteIndex_ to _targetByteIndex_ + 1.
+ 1. Return *undefined*.
+
+
+
+
+
+
+
%TypedArray%.prototype.slice ( _start_, _end_ )
+
The interpretation and use of the arguments of %TypedArray%`.prototype.slice` are the same as for `Array.prototype.slice` as defined in . The following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _valid_ be ? ValidateTypedArray(_O_).
+ 1. Let _len_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. Let _relativeStart_ be ? ToInteger(_start_).
+ 1. If _relativeStart_ < 0, let _k_ be max((_len_ + _relativeStart_),0); else let _k_ be min(_relativeStart_, _len_).
+ 1. If _end_ is *undefined*, let _relativeEnd_ be _len_; else let _relativeEnd_ be ? ToInteger(_end_).
+ 1. If _relativeEnd_ < 0, let _final_ be max((_len_ + _relativeEnd_),0); else let _final_ be min(_relativeEnd_, _len_).
+ 1. Let _count_ be max(_final_ - _k_, 0).
+ 1. Let _defaultConstructor_ be the intrinsic object listed in column one of for the value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _C_ be ? SpeciesConstructor(_O_, _defaultConstructor_).
+ 1. Let _A_ be ? AllocateTypedArray(_C_, _count_).
+ 1. Let _srcName_ be the String value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _srcType_ be the String value of the Element Type value in for _srcName_.
+ 1. Let _targetName_ be the String value of _A_'s [[TypedArrayName]] internal slot.
+ 1. Let _targetType_ be the String value of the Element Type value in for _targetName_.
+ 1. If SameValue(_srcType_, _targetType_) is *false*, then
+ 1. Let _n_ be 0.
+ 1. Repeat, while _k_ < _final_
+ 1. Let _Pk_ be ToString(_k_).
+ 1. Let _kValue_ be ? Get(_O_, _Pk_).
+ 1. Let _status_ be ? Set(_A_, ToString(_n_), _kValue_, *true* ).
+ 1. Increase _k_ by 1.
+ 1. Increase _n_ by 1.
+ 1. Else if _count_ > 0, then
+ 1. Let _srcBuffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_srcBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _targetBuffer_ be the value of _A_'s [[ViewedArrayBuffer]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for _srcType_.
+ 1. NOTE: If _srcType_ and _targetType_ are the same the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
+ 1. Let _srcByteOffet_ be the value of _O_'s [[ByteOffset]] internal slot.
+ 1. Let _targetByteIndex_ be 0.
+ 1. Let _srcByteIndex_ be (_k_ × _elementSize_) + _srcByteOffet_.
+ 1. Repeat, while _targetByteIndex_ < _count_ × _elementSize_
+ 1. Let _value_ be GetValueFromBuffer(_srcBuffer_, _srcByteIndex_, `"Uint8"`).
+ 1. Perform SetValueInBuffer(_targetBuffer_, _targetByteIndex_, `"Uint8"`, _value_).
+ 1. Increase _srcByteIndex_ by 1.
+ 1. Increase _targetByteIndex_ by 1.
+ 1. Return _A_.
+
+
This function is not generic. The *this* value must be an object with a [[TypedArrayName]] internal slot.
%TypedArray%`.prototype.some` is a distinct function that implements the same algorithm as `Array.prototype.some` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to _callbackfn_ may cause the *this* value to become detached.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
The `length` property of the `some` method is 1.
+
+
+
+
+
%TypedArray%.prototype.sort ( _comparefn_ )
+
%TypedArray%`.prototype.sort` is a distinct function that, except as described below, implements the same requirements as those of `Array.prototype.sort` as defined in . The implementation of the %TypedArray%`.prototype.sort` specification may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. The only internal methods of the *this* object that the algorithm may call are [[Get]] and [[Set]].
+
This function is not generic. The *this* value must be an object with a [[TypedArrayName]] internal slot.
+
Upon entry, the following steps are performed to initialize evaluation of the `sort` function. These steps are used instead of the entry steps in :
+
+ 1. Let _obj_ be the *this* value as the argument.
+ 1. Let _buffer_ be ? ValidateTypedArray(_obj_).
+ 1. Let _len_ be the value of _obj_'s [[ArrayLength]] internal slot.
+
+
The implementation defined sort order condition for exotic objects is not applied by %TypedArray%`.prototype.sort`.
+
The following version of SortCompare is used by %TypedArray%`.prototype.sort`. It performs a numeric comparison rather than the string comparison used in . SortCompare has access to the _comparefn_ and _buffer_ values of the current invocation of the `sort` method.
+
When the TypedArray SortCompare abstract operation is called with two arguments _x_ and _y_, the following steps are taken:
+
+ 1. Assert: Both Type(_x_) and Type(_y_) is Number.
+ 1. If the argument _comparefn_ is not *undefined*, then
+ 1. Let _v_ be ? Call(_comparefn_, *undefined*, « _x_, _y_ »).
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. If _v_ is *NaN*, return +0.
+ 1. Return _v_.
+ 1. If _x_ and _y_ are both *NaN*, return +0.
+ 1. If _x_ is *NaN*, return 1.
+ 1. If _y_ is *NaN*, return -1.
+ 1. If _x_ < _y_, return -1.
+ 1. If _x_ > _y_, return 1.
+ 1. If _x_ is -0 and _y_ is +0, return -1.
+ 1. If _x_ is +0 and _y_ is -0, return 1.
+ 1. Return +0.
+
+
+
Because *NaN* always compares greater than any other value, *NaN* property values always sort to the end of the result when _comparefn_ is not provided.
Returns a new _TypedArray_ object whose element type is the same as this _TypedArray_ and whose ArrayBuffer is the same as the ArrayBuffer of this _TypedArray_, referencing the elements at _begin_, inclusive, up to _end_, exclusive. If either _begin_ or _end_ is negative, it refers to an index from the end of the array, as opposed to from the beginning.
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[TypedArrayName]] internal slot, throw a *TypeError* exception.
+ 1. Assert: _O_ has a [[ViewedArrayBuffer]] internal slot.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. Let _srcLength_ be the value of _O_'s [[ArrayLength]] internal slot.
+ 1. Let _relativeBegin_ be ? ToInteger(_begin_).
+ 1. If _relativeBegin_ < 0, let _beginIndex_ be max((_srcLength_ + _relativeBegin_), 0); else let _beginIndex_ be min(_relativeBegin_, _srcLength_).
+ 1. If _end_ is *undefined*, let _relativeEnd_ be _srcLength_; else, let _relativeEnd_ be ? ToInteger(_end_).
+ 1. If _relativeEnd_ < 0, let _endIndex_ be max((_srcLength_ + _relativeEnd_), 0); else let _endIndex_ be min(_relativeEnd_, _srcLength_).
+ 1. Let _newLength_ be max(_endIndex_ - _beginIndex_, 0).
+ 1. Let _constructorName_ be the String value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for _constructorName_.
+ 1. Let _srcByteOffset_ be the value of _O_'s [[ByteOffset]] internal slot.
+ 1. Let _beginByteOffset_ be _srcByteOffset_ + _beginIndex_ × _elementSize_.
+ 1. Let _defaultConstructor_ be the intrinsic object listed in column one of for _constructorName_.
+ 1. Let _constructor_ be ? SpeciesConstructor(_O_, _defaultConstructor_).
+ 1. Let _argumentsList_ be « _buffer_, _beginByteOffset_, _newLength_ ».
+ 1. Return Construct(_constructor_, _argumentsList_).
+
+
This function is not generic. The *this* value must be an object with a [[TypedArrayName]] internal slot.
%TypedArray%`.prototype.toLocaleString` is a distinct function that implements the same algorithm as `Array.prototype.toLocaleString` as defined in except that the *this* object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of `"length"`. The implementation of the algorithm may be optimized with the knowledge that the *this* value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.
+
This function is not generic. ValidateTypedArray is applied to the *this* value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.
+
+
If the ECMAScript implementation includes the ECMA-402 Internationalization API this function is based upon the algorithm for `Array.prototype.toLocaleString` that is in the ECMA-402 specification.
+
+
+
+
+
+
%TypedArray%.prototype.toString ( )
+
The initial value of the %TypedArray%`.prototype.toString` data property is the same built-in function object as the `Array.prototype.toString` method defined in .
+
+
+
+
+
%TypedArray%.prototype.values ( )
+
The following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. Let _valid_ be ? ValidateTypedArray(_O_).
+ 1. Return CreateArrayIterator(_O_, `"value"`).
+
+
+
+
+
+
%TypedArray%.prototype [ @@iterator ] ( )
+
The initial value of the @@iterator property is the same function object as the initial value of the %TypedArray%`.prototype.values` property.
+
+
+
+
+
get %TypedArray%.prototype [ @@toStringTag ]
+
%TypedArray%.`prototype[@@toStringTag]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, return *undefined*.
+ 1. If _O_ does not have a [[TypedArrayName]] internal slot, return *undefined*.
+ 1. Let _name_ be the value of _O_'s [[TypedArrayName]] internal slot.
+ 1. Assert: _name_ is a String value.
+ 1. Return _name_.
+
+
This property has the attributes { [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
The initial value of the `name` property of this function is `"get [Symbol.toStringTag]"`.
+
+
+
+
+
+
The _TypedArray_ Constructors
+
Each of the _TypedArray_ constructor objects is an intrinsic object that has the structure described below, differing only in the name used as the constructor name instead of _TypedArray_, in .
+
The _TypedArray_ constructors are not intended to be called as a function and will throw an exception when called in that manner.
+
The _TypedArray_ constructors are designed to be subclassable. They may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified _TypedArray_ behaviour must include a `super` call to the _TypedArray_ constructor to create and initialize the subclass instance with the internal state necessary to support the %TypedArray`%.prototype` built-in methods.
+
+
+
+
_TypedArray_( ... _argumentsList_)
+
A _TypedArray_ constructor with a list of arguments _argumentsList_ performs the following steps:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _here_ be the active function.
+ 1. Let _super_ be ? _here_.[[GetPrototypeOf]]().
+ 1. If IsConstructor(_super_) is *false*, throw a *TypeError* exception.
+ 1. Let _argumentsList_ be the _argumentsList_ argument of the [[Construct]] internal method that invoked the active function.
+ 1. Return Construct(_super_, _argumentsList_, NewTarget).
+
+
+
+
+
+
+
Properties of the _TypedArray_ Constructors
+
The value of the [[Prototype]] internal slot of each _TypedArray_ constructor is the %TypedArray% intrinsic object ().
+
Each _TypedArray_ constructor has a [[TypedArrayConstructorName]] internal slot property whose value is the String value of the constructor name specified for it in .
+
Each _TypedArray_ constructor has a `name` property whose value is the String value of the constructor name specified for it in .
+
Besides a `length` property (whose value is 3), each _TypedArray_ constructor has the following properties:
+
+
+
+
_TypedArray_.BYTES_PER_ELEMENT
+
The value of _TypedArray_.BYTES_PER_ELEMENT is the Number value of the Element Size value specified in for _TypedArray_.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
_TypedArray_.prototype
+
The initial value of _TypedArray_.prototype is the corresponding _TypedArray_ prototype intrinsic object ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of _TypedArray_ Prototype Objects
+
The value of the [[Prototype]] internal slot of a _TypedArray_ prototype object is the intrinsic object %TypedArrayPrototype% (). A _TypedArray_ prototype object is an ordinary object. It does not have a [[ViewedArrayBuffer]] or any other of the internal slots that are specific to _TypedArray_ instance objects.
+
+
+
+
_TypedArray_.prototype.BYTES_PER_ELEMENT
+
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value of the Element Size value specified in for _TypedArray_.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
_TypedArray_.prototype.constructor
+
The initial value of a TypedArray.prototype.constructor is the corresponding %_TypedArray_% intrinsic object.
+
+
+
+
+
+
Properties of _TypedArray_ Instances
+
_TypedArray_ instances are Integer Indexed exotic objects. Each _TypedArray_ instance inherits properties from the corresponding _TypedArray_ prototype object. Each _TypedArray_ instance has the following internal slots: [[TypedArrayName]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]], and [[ArrayLength]].
+
+
+
+
+
+
+
Keyed Collection
+
+
+
+
Map Objects
+
Map objects are collections of key/value pairs where both the keys and values may be arbitrary ECMAScript language values. A distinct key value may only occur in one key/value pair within the Map's collection. Distinct key values are discriminated using the SameValueZero comparison algorithm.
+
Map object must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structures used in this Map objects specification is only intended to describe the required observable semantics of Map objects. It is not intended to be a viable implementation model.
+
+
+
+
The Map Constructor
+
The Map constructor is the %Map% intrinsic object and the initial value of the `Map` property of the global object. When called as a constructor it creates and initializes a new Map object. `Map` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `Map` constructor is designed to be subclassable. It may be used as the value in an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Map` behaviour must include a `super` call to the `Map` constructor to create and initialize the subclass instance with the internal state necessary to support the `Map.prototype` built-in methods.
+
+
+
+
Map ( [ _iterable_ ] )
+
When the `Map` function is called with optional argument the following steps are taken:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _map_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%MapPrototype%"`, « [[MapData]] » ).
+ 1. Set _map_'s [[MapData]] internal slot to a new empty List.
+ 1. If _iterable_ is not present, let _iterable_ be *undefined*.
+ 1. If _iterable_ is either *undefined* or *null*, let _iter_ be *undefined*.
+ 1. Else,
+ 1. Let _adder_ be ? Get(_map_, `"set"`).
+ 1. If IsCallable(_adder_) is *false*, throw a *TypeError* exception.
+ 1. Let _iter_ be ? GetIterator(_iterable_).
+ 1. If _iter_ is *undefined*, return _map_.
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iter_).
+ 1. If _next_ is *false*, return _map_.
+ 1. Let _nextItem_ be ? IteratorValue(_next_).
+ 1. If Type(_nextItem_) is not Object, then
+ 1. Let _error_ be Completion{[[type]]: ~throw~, [[value]]: a newly created *TypeError* object, [[target]]:~empty~}.
+ 1. Return IteratorClose(_iter_, _error_).
+ 1. Let _k_ be Get(_nextItem_, `"0"`).
+ 1. If _k_ is an abrupt completion, return IteratorClose(_iter_, _k_).
+ 1. Let _v_ be Get(_nextItem_, `"1"`).
+ 1. If _v_ is an abrupt completion, return IteratorClose(_iter_, _v_).
+ 1. Let _status_ be Call(_adder_, _map_, « _k_.[[value]], _v_.[[value]] »).
+ 1. If _status_ is an abrupt completion, return IteratorClose(_iter_, _status_).
+
+
+
If the parameter _iterable_ is present, it is expected to be an object that implements an @@iterator method that returns an iterator object that produces a two element array-like object whose first element is a value that will be used as a Map key and whose second element is the value to associate with that key.
+
+
+
+
+
+
+
Properties of the Map Constructor
+
The value of the [[Prototype]] internal slot of the Map constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 0), the Map constructor has the following properties:
+
+
+
+
Map.prototype
+
The initial value of `Map.prototype` is the intrinsic object %MapPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
get Map [ @@species ]
+
`Map[@@species]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
Methods that create derived collection objects should call @@species to determine the constructor to use to create the derived objects. Subclass constructor may over-ride @@species to change the default constructor assignment.
+
+
+
+
+
+
+
Properties of the Map Prototype Object
+
The Map prototype object is the intrinsic object %MapPrototype%. The value of the [[Prototype]] internal slot of the Map prototype object is the intrinsic object %ObjectPrototype% (). The Map prototype object is an ordinary object. It does not have a [[MapData]] internal slot.
+
+
+
+
Map.prototype.clear ( )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. Set _p_.[[key]] to ~empty~.
+ 1. Set _p_.[[value]] to ~empty~.
+ 1. Return *undefined*.
+
+
+
The existing [[MapData]] List is preserved because there may be existing MapIterator objects that are suspended midway through iterating over that List.
+
+
+
+
+
+
Map.prototype.constructor
+
The initial value of `Map.prototype.constructor` is the intrinsic object %Map%.
+
+
+
+
+
Map.prototype.delete ( _key_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValueZero(_p_.[[key]], _key_) is *true*, then
+ 1. Set _p_.[[key]] to ~empty~.
+ 1. Set _p_.[[value]] to ~empty~.
+ 1. Return *true*.
+ 1. Return *false*.
+
+
+
The value ~empty~ is used as a specification device to indicate that an entry has been deleted. Actual implementations may take other actions such as physically removing the entry from internal data structures.
+
+
+
+
+
+
Map.prototype.entries ( )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. Return CreateMapIterator(_M_, `"key+value"`).
+
+
+
+
+
+
When the `forEach` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Repeat for each Record {[[key]], [[value]]} _e_ that is an element of _entries_, in original key insertion order
+ 1. If _e_.[[key]] is not ~empty~, then
+ 1. Let _funcResult_ be ? Call(_callbackfn_, _T_, « _e_.[[value]], _e_.[[key]], _M_ »).
+ 1. Return *undefined*.
+
+
The `length` property of the `forEach` method is 1.
+
+
_callbackfn_ should be a function that accepts three arguments. `forEach` calls _callbackfn_ once for each key/value pair present in the map object, in key insertion order. _callbackfn_ is called only for keys of the map which actually exist; it is not called for keys that have been deleted from the map.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the value of the item, the key of the item, and the Map object being traversed.
+
`forEach` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_. Each entry of a map's [[MapData]] is only visited once. New keys added after the call to `forEach` begins are visited. A key will be revisited if it is deleted after it has been visited and then re-added before the `forEach` call completes. Keys that are deleted after the call to `forEach` begins and before being visited are not visited unless the key is added again before the `forEach` call completes.
+
+
+
+
+
+
Map.prototype.get ( _key_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValueZero(_p_.[[key]], _key_) is *true*, return _p_.[[value]].
+ 1. Return *undefined*.
+
+
+
+
+
+
Map.prototype.has ( _key_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValueZero(_p_.[[key]], _key_) is *true*, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
Map.prototype.keys ( )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. Return CreateMapIterator(_M_, `"key"`).
+
+
+
+
+
+
Map.prototype.set ( _key_ , _value_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValueZero(_p_.[[key]], _key_) is *true*, then
+ 1. Set _p_.[[value]] to _value_.
+ 1. Return _M_.
+ 1. If _key_ is -0, let _key_ be +0.
+ 1. Let _p_ be the Record {[[key]]: _key_, [[value]]: _value_}.
+ 1. Append _p_ as the last element of _entries_.
+ 1. Return _M_.
+
+
+
+
+
+
get Map.prototype.size
+
Map.prototype.size is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[MapData]] internal slot.
+ 1. Let _count_ be 0.
+ 1. For each Record {[[key]], [[value]]} _p_ that is an element of _entries_
+ 1. If _p_.[[key]] is not ~empty~, set _count_ to _count_+1.
+ 1. Return _count_.
+
+
+
+
+
+
Map.prototype.values ( )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. Return CreateMapIterator(_M_, `"value"`).
+
+
+
+
+
+
Map.prototype [ @@iterator ]( )
+
The initial value of the @@iterator property is the same function object as the initial value of the `entries` property.
+
+
+
+
+
Map.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Map"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Map Instances
+
Map instances are ordinary objects that inherit properties from the Map prototype. Map instances also have a [[MapData]] internal slot.
+
+
+
+
+
Map Iterator Objects
+
A Map Iterator is an object, that represents a specific iteration over some specific Map instance object. There is not a named constructor for Map Iterator objects. Instead, map iterator objects are created by calling certain methods of Map instance objects.
+
+
+
+
CreateMapIterator Abstract Operation
+
Several methods of Map objects return Iterator objects. The abstract operation CreateMapIterator with arguments _map_ and _kind_ is used to create such iterator objects. It performs the following steps:
+
+ 1. If Type(_map_) is not Object, throw a *TypeError* exception.
+ 1. If _map_ does not have a [[MapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _iterator_ be ObjectCreate(%MapIteratorPrototype%, « [[Map]], [[MapNextIndex]], [[MapIterationKind]] »).
+ 1. Set _iterator_'s [[Map]] internal slot to _map_.
+ 1. Set _iterator_'s [[MapNextIndex]] internal slot to 0.
+ 1. Set _iterator_'s [[MapIterationKind]] internal slot to _kind_.
+ 1. Return _iterator_.
+
+
+
+
+
+
The %MapIteratorPrototype% Object
+
All Map Iterator Objects inherit properties from the %MapIteratorPrototype% intrinsic object. The %MapIteratorPrototype% intrinsic object is an ordinary object and its [[Prototype]] internal slot is the %IteratorPrototype% intrinsic object (). In addition, %MapIteratorPrototype% has the following properties:
+
+
+
+
%MapIteratorPrototype%.next ( )
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have all of the internal slots of a Map Iterator Instance (), throw a *TypeError* exception.
+ 1. Let _m_ be the value of the [[Map]] internal slot of _O_.
+ 1. Let _index_ be the value of the [[MapNextIndex]] internal slot of _O_.
+ 1. Let _itemKind_ be the value of the [[MapIterationKind]] internal slot of _O_.
+ 1. If _m_ is *undefined*, return CreateIterResultObject(*undefined*, *true*).
+ 1. Assert: _m_ has a [[MapData]] internal slot.
+ 1. Let _entries_ be the List that is the value of the [[MapData]] internal slot of _m_.
+ 1. Repeat while _index_ is less than the total number of elements of _entries_. The number of elements must be redetermined each time this method is evaluated.
+ 1. Let _e_ be the Record {[[key]], [[value]]} that is the value of _entries_[_index_].
+ 1. Set _index_ to _index_+1.
+ 1. Set the [[MapNextIndex]] internal slot of _O_ to _index_.
+ 1. If _e_.[[key]] is not ~empty~, then
+ 1. If _itemKind_ is `"key"`, let _result_ be _e_.[[key]].
+ 1. Else if _itemKind_ is `"value"`, let _result_ be _e_.[[value]].
+ 1. Else,
+ 1. Assert: _itemKind_ is `"key+value"`.
+ 1. Let _result_ be CreateArrayFromList(« _e_.[[key]], _e_.[[value]] »).
+ 1. Return CreateIterResultObject(_result_, *false*).
+ 1. Set the [[Map]] internal slot of _O_ to *undefined*.
+ 1. Return CreateIterResultObject(*undefined*, *true*).
+
+
+
+
+
+
%MapIteratorPrototype% [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Map Iterator"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Map Iterator Instances
+
Map Iterator instances are ordinary objects that inherit properties from the %MapIteratorPrototype% intrinsic object. Map Iterator instances are initially created with the internal slots described in .
+
+
+
+
+
+ Internal Slot
+
+
+ Description
+
+
+
+
+ [[Map]]
+
+
+ The Map object that is being iterated.
+
+
+
+
+ [[MapNextIndex]]
+
+
+ The integer index of the next Map data element to be examined by this iterator.
+
+
+
+
+ [[MapIterationKind]]
+
+
+ A String value that identifies what is to be returned for each element of the iteration. The possible values are: `"key"`, `"value"`, `"key+value"`.
+
+
+
+
+
+
+
+
+
+
+
+
Set Objects
+
Set objects are collections of ECMAScript language values. A distinct value may only occur once as an element of a Set's collection. Distinct values are discriminated using the SameValueZero comparison algorithm.
+
Set objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structures used in this Set objects specification is only intended to describe the required observable semantics of Set objects. It is not intended to be a viable implementation model.
+
+
+
+
The Set Constructor
+
The Set constructor is the %Set% intrinsic object and the initial value of the `Set` property of the global object. When called as a constructor it creates and initializes a new Set object. `Set` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `Set` constructor is designed to be subclassable. It may be used as the value in an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Set` behaviour must include a `super` call to the `Set` constructor to create and initialize the subclass instance with the internal state necessary to support the `Set.prototype` built-in methods.
+
+
+
+
Set ( [ _iterable_ ] )
+
When the `Set` function is called with optional argument _iterable_ the following steps are taken:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _set_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%SetPrototype%"`, « [[SetData]] » ).
+ 1. Set _set_'s [[SetData]] internal slot to a new empty List.
+ 1. If _iterable_ is not present, let _iterable_ be *undefined*.
+ 1. If _iterable_ is either *undefined* or *null*, let _iter_ be *undefined*.
+ 1. Else,
+ 1. Let _adder_ be ? Get(_set_, `"add"`).
+ 1. If IsCallable(_adder_) is *false*, throw a *TypeError* exception.
+ 1. Let _iter_ be ? GetIterator(_iterable_).
+ 1. If _iter_ is *undefined*, return _set_.
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iter_).
+ 1. If _next_ is *false*, return _set_.
+ 1. Let _nextValue_ be ? IteratorValue(_next_).
+ 1. Let _status_ be Call(_adder_, _set_, « _nextValue_.[[value]] »).
+ 1. If _status_ is an abrupt completion, return IteratorClose(_iter_, _status_).
+
+
+
+
+
+
+
Properties of the Set Constructor
+
The value of the [[Prototype]] internal slot of the Set constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 0), the Set constructor has the following properties:
+
+
+
+
Set.prototype
+
The initial value of `Set.prototype` is the intrinsic %SetPrototype% object ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
get Set [ @@species ]
+
`Set[@@species]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
Methods that create derived collection objects should call @@species to determine the constructor to use to create the derived objects. Subclass constructor may over-ride @@species to change the default constructor assignment.
+
+
+
+
+
+
+
Properties of the Set Prototype Object
+
The Set prototype object is the intrinsic object %SetPrototype%. The value of the [[Prototype]] internal slot of the Set prototype object is the intrinsic object %ObjectPrototype% (). The Set prototype object is an ordinary object. It does not have a [[SetData]] internal slot.
+
+
+
+
Set.prototype.add ( _value_ )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[SetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. If _e_ is not ~empty~ and SameValueZero(_e_, _value_) is *true*, then
+ 1. Return _S_.
+ 1. If _value_ is -0, let _value_ be +0.
+ 1. Append _value_ as the last element of _entries_.
+ 1. Return _S_.
+
+
+
+
+
+
Set.prototype.clear ( )
+
The following steps are taken:
+
+ 1. Let _S_ be *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[SetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. Replace the element of _entries_ whose value is _e_ with an element whose value is ~empty~.
+ 1. Return *undefined*.
+
+
+
+
+
+
Set.prototype.constructor
+
The initial value of `Set.prototype.constructor` is the intrinsic object %Set%.
+
+
+
+
+
Set.prototype.delete ( _value_ )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[SetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. If _e_ is not ~empty~ and SameValueZero(_e_, _value_) is *true*, then
+ 1. Replace the element of _entries_ whose value is _e_ with an element whose value is ~empty~.
+ 1. Return *true*.
+ 1. Return *false*.
+
+
+
The value ~empty~ is used as a specification device to indicate that an entry has been deleted. Actual implementations may take other actions such as physically removing the entry from internal data structures.
+
+
+
+
+
+
Set.prototype.entries ( )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateSetIterator(_S_, `"key+value"`).
+
+
+
For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.
When the `forEach` method is called with one or two arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. If IsCallable(_callbackfn_) is *false*, throw a *TypeError* exception.
+ 1. If _thisArg_ was supplied, let _T_ be _thisArg_; else let _T_ be *undefined*.
+ 1. Let _entries_ be the List that is the value of _S_'s [[SetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_, in original insertion order
+ 1. If _e_ is not ~empty~, then
+ 1. Let _funcResult_ be ? Call(_callbackfn_, _T_, « _e_, _e_, _S_ »).
+ 1. Return *undefined*.
+
+
The `length` property of the `forEach` method is 1.
+
+
_callbackfn_ should be a function that accepts three arguments. `forEach` calls _callbackfn_ once for each value present in the set object, in value insertion order. _callbackfn_ is called only for values of the Set which actually exist; it is not called for keys that have been deleted from the set.
+
If a _thisArg_ parameter is provided, it will be used as the *this* value for each invocation of _callbackfn_. If it is not provided, *undefined* is used instead.
+
_callbackfn_ is called with three arguments: the first two arguments are a value contained in the Set. The same value is passed for both arguments. The Set object being traversed is passed as the third argument.
+
The _callbackfn_ is called with three arguments to be consistent with the call back functions used by `forEach` methods for Map and Array. For Sets, each item value is considered to be both the key and the value.
+
`forEach` does not directly mutate the object on which it is called but the object may be mutated by the calls to _callbackfn_.
+
Each value is normally visited only once. However, a value will be revisited if it is deleted after it has been visited and then re-added before the `forEach` call completes. Values that are deleted after the call to `forEach` begins and before being visited are not visited unless the value is added again before the `forEach` call completes. New values added after the call to `forEach` begins are visited.
+
+
+
+
+
+
Set.prototype.has ( _value_ )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[SetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. If _e_ is not ~empty~ and SameValueZero(_e_, _value_) is *true*, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
Set.prototype.keys ( )
+
The initial value of the `keys` property is the same function object as the initial value of the `values` property.
+
+
For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.
+
+
+
+
+
+
get Set.prototype.size
+
`Set.prototype.size` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[SetData]] internal slot.
+ 1. Let _count_ be 0.
+ 1. For each _e_ that is an element of _entries_
+ 1. If _e_ is not ~empty~, set _count_ to _count_+1.
+ 1. Return _count_.
+
+
+
+
+
+
Set.prototype.values ( )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateSetIterator(_S_, `"value"`).
+
+
+
+
+
+
Set.prototype [ @@iterator ] ( )
+
The initial value of the @@iterator property is the same function object as the initial value of the `values` property.
+
+
+
+
+
Set.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Set"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Set Instances
+
Set instances are ordinary objects that inherit properties from the Set prototype. Set instances also have a [[SetData]] internal slot.
+
+
+
+
+
Set Iterator Objects
+
A Set Iterator is an ordinary object, with the structure defined below, that represents a specific iteration over some specific Set instance object. There is not a named constructor for Set Iterator objects. Instead, set iterator objects are created by calling certain methods of Set instance objects.
+
+
+
+
CreateSetIterator Abstract Operation
+
Several methods of Set objects return Iterator objects. The abstract operation CreateSetIterator with arguments _set_ and _kind_ is used to create such iterator objects. It performs the following steps:
+
+ 1. If Type(_set_) is not Object, throw a *TypeError* exception.
+ 1. If _set_ does not have a [[SetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _iterator_ be ObjectCreate(%SetIteratorPrototype%, « [[IteratedSet]], [[SetNextIndex]], [[SetIterationKind]] »).
+ 1. Set _iterator_'s [[IteratedSet]] internal slot to _set_.
+ 1. Set _iterator_'s [[SetNextIndex]] internal slot to 0.
+ 1. Set _iterator_'s [[SetIterationKind]] internal slot to _kind_.
+ 1. Return _iterator_.
+
+
+
+
+
+
The %SetIteratorPrototype% Object
+
All Set Iterator Objects inherit properties from the %SetIteratorPrototype% intrinsic object. The %SetIteratorPrototype% intrinsic object is an ordinary object and its [[Prototype]] internal slot is the %IteratorPrototype% intrinsic object (). In addition, %SetIteratorPrototype% has the following properties:
+
+
+
+
%SetIteratorPrototype%.next ( )
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have all of the internal slots of a Set Iterator Instance (), throw a *TypeError* exception.
+ 1. Let _s_ be the value of the [[IteratedSet]] internal slot of _O_.
+ 1. Let _index_ be the value of the [[SetNextIndex]] internal slot of _O_.
+ 1. Let _itemKind_ be the value of the [[SetIterationKind]] internal slot of _O_.
+ 1. If _s_ is *undefined*, return CreateIterResultObject(*undefined*, *true*).
+ 1. Assert: _s_ has a [[SetData]] internal slot.
+ 1. Let _entries_ be the List that is the value of the [[SetData]] internal slot of _s_.
+ 1. Repeat while _index_ is less than the total number of elements of _entries_. The number of elements must be redetermined each time this method is evaluated.
+ 1. Let _e_ be _entries_[_index_].
+ 1. Set _index_ to _index_+1.
+ 1. Set the [[SetNextIndex]] internal slot of _O_ to _index_.
+ 1. If _e_ is not ~empty~, then
+ 1. If _itemKind_ is `"key+value"`, then
+ 1. Return CreateIterResultObject(CreateArrayFromList(« _e_, _e_ »), *false*).
+ 1. Return CreateIterResultObject(_e_, *false*).
+ 1. Set the [[IteratedSet]] internal slot of _O_ to *undefined*.
+ 1. Return CreateIterResultObject(*undefined*, *true*).
+
+
+
+
+
+
%SetIteratorPrototype% [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Set Iterator"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Set Iterator Instances
+
Set Iterator instances are ordinary objects that inherit properties from the %SetIteratorPrototype% intrinsic object. Set Iterator instances are initially created with the internal slots specified in .
+
+
+
+
+
+ Internal Slot
+
+
+ Description
+
+
+
+
+ [[IteratedSet]]
+
+
+ The Set object that is being iterated.
+
+
+
+
+ [[SetNextIndex]]
+
+
+ The integer index of the next Set data element to be examined by this iterator
+
+
+
+
+ [[SetIterationKind]]
+
+
+ A String value that identifies what is to be returned for each element of the iteration. The possible values are: `"key"`, `"value"`, `"key+value"`. `"key"` and `"value"` have the same meaning.
+
+
+
+
+
+
+
+
+
+
+
+
WeakMap Objects
+
WeakMap objects are collections of key/value pairs where the keys are objects and values may be arbitrary ECMAScript language values. A WeakMap may be queried to see if it contains a key/value pair with a specific key, but no mechanism is provided for enumerating the objects it holds as keys. If an object that is being used as the key of a WeakMap key/value pair is only reachable by following a chain of references that start within that WeakMap, then that key/value pair is inaccessible and is automatically removed from the WeakMap. WeakMap implementations must detect and remove such key/value pairs and any associated resources.
+
An implementation may impose an arbitrarily determined latency between the time a key/value pair of a WeakMap becomes inaccessible and the time when the key/value pair is removed from the WeakMap. If this latency was observable to ECMAScript program, it would be a source of indeterminacy that could impact program execution. For that reason, an ECMAScript implementation must not provide any means to observe a key of a WeakMap that does not require the observer to present the observed key.
+
WeakMap objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of key/value pairs in the collection. The data structure used in this WeakMap objects specification are only intended to describe the required observable semantics of WeakMap objects. It is not intended to be a viable implementation model.
+
+
WeakMap and WeakSets are intended to provide mechanisms for dynamically associating state with an object in a manner that does not “leak” memory resources if, in the absence of the WeakMap or WeakSet, the object otherwise became inaccessible and subject to resource reclamation by the implementation's garbage collection mechanisms. This characteristic can be achieved by using an inverted per-object mapping of weak map instances to keys. Alternatively each weak map may internally store its key to value mappings but this approach requires coordination between the WeakMap or WeakSet implementation and the garbage collector. The following references describe mechanism that may be useful to implementations of WeakMap and WeakSets:
+
Barry Hayes. 1997. Ephemerons: a new finalization mechanism. In Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '97), A. Michael Berman (Ed.). ACM, New York, NY, USA, 176-183, http://doi.acm.org/10.1145/263698.263733.
The WeakMap constructor is the %WeakMap% intrinsic object and the initial value of the `WeakMap` property of the global object. When called as a constructor it creates and initializes a new WeakMap object. `WeakMap` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `WeakMap` constructor is designed to be subclassable. It may be used as the value in an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `WeakMap` behaviour must include a `super` call to the `WeakMap` constructor to create and initialize the subclass instance with the internal state necessary to support the `WeakMap.prototype` built-in methods.
+
+
+
+
WeakMap ( [ _iterable_ ] )
+
When the `WeakMap` function is called with optional argument _iterable_ the following steps are taken:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _map_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%WeakMapPrototype%"`, « [[WeakMapData]] » ).
+ 1. Set _map_'s [[WeakMapData]] internal slot to a new empty List.
+ 1. If _iterable_ is not present, let _iterable_ be *undefined*.
+ 1. If _iterable_ is either *undefined* or *null*, let _iter_ be *undefined*.
+ 1. Else,
+ 1. Let _adder_ be ? Get(_map_, `"set"`).
+ 1. If IsCallable(_adder_) is *false*, throw a *TypeError* exception.
+ 1. Let _iter_ be ? GetIterator(_iterable_).
+ 1. If _iter_ is *undefined*, return _map_.
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iter_).
+ 1. If _next_ is *false*, return _map_.
+ 1. Let _nextItem_ be ? IteratorValue(_next_).
+ 1. If Type(_nextItem_) is not Object, then
+ 1. Let _error_ be Completion{[[type]]: ~throw~, [[value]]: a newly created *TypeError* object, [[target]]:~empty~}.
+ 1. Return IteratorClose(_iter_, _error_).
+ 1. Let _k_ be Get(_nextItem_, `"0"`).
+ 1. If _k_ is an abrupt completion, return IteratorClose(_iter_, _k_).
+ 1. Let _v_ be Get(_nextItem_, `"1"`).
+ 1. If _v_ is an abrupt completion, return IteratorClose(_iter_, _v_).
+ 1. Let _status_ be Call(_adder_, _map_, « _k_.[[value]], _v_.[[value]] »).
+ 1. If _status_ is an abrupt completion, return IteratorClose(_iter_, _status_).
+
+
+
If the parameter _iterable_ is present, it is expected to be an object that implements an @@iterator method that returns an iterator object that produces a two element array-like object whose first element is a value that will be used as a WeakMap key and whose second element is the value to associate with that key.
+
+
+
+
+
+
+
Properties of the WeakMap Constructor
+
The value of the [[Prototype]] internal slot of the WeakMap constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 0), the WeakMap constructor has the following properties:
+
+
+
+
WeakMap.prototype
+
The initial value of `WeakMap.prototype` is the intrinsic object %WeakMapPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the WeakMap Prototype Object
+
The WeakMap prototype object is the intrinsic object %WeakMapPrototype%. The value of the [[Prototype]] internal slot of the WeakMap prototype object is the intrinsic object %ObjectPrototype% (). The WeakMap prototype object is an ordinary object. It does not have a [[WeakMapData]] internal slot.
+
+
+
+
WeakMap.prototype.constructor
+
The initial value of `WeakMap.prototype.constructor` is the intrinsic object %WeakMap%.
+
+
+
+
+
WeakMap.prototype.delete ( _key_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[WeakMapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[WeakMapData]] internal slot.
+ 1. If Type(_key_) is not Object, return *false*.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValue(_p_.[[key]], _key_) is *true*, then
+ 1. Set _p_.[[key]] to ~empty~.
+ 1. Set _p_.[[value]] to ~empty~.
+ 1. Return *true*.
+ 1. Return *false*.
+
+
+
The value ~empty~ is used as a specification device to indicate that an entry has been deleted. Actual implementations may take other actions such as physically removing the entry from internal data structures.
+
+
+
+
+
+
WeakMap.prototype.get ( _key_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[WeakMapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[WeakMapData]] internal slot.
+ 1. If Type(_key_) is not Object, return *undefined*.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValue(_p_.[[key]], _key_) is *true*, return _p_.[[value]].
+ 1. Return *undefined*.
+
+
+
+
+
+
WeakMap.prototype.has ( _key_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[WeakMapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[WeakMapData]] internal slot.
+ 1. If Type(_key_) is not Object, return *false*.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValue(_p_.[[key]], _key_) is *true*, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
WeakMap.prototype.set ( _key_ , _value_ )
+
The following steps are taken:
+
+ 1. Let _M_ be the *this* value.
+ 1. If Type(_M_) is not Object, throw a *TypeError* exception.
+ 1. If _M_ does not have a [[WeakMapData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _M_'s [[WeakMapData]] internal slot.
+ 1. If Type(_key_) is not Object, throw a *TypeError* exception.
+ 1. Repeat for each Record {[[key]], [[value]]} _p_ that is an element of _entries_,
+ 1. If _p_.[[key]] is not ~empty~ and SameValue(_p_.[[key]], _key_) is *true*, then
+ 1. Set _p_.[[value]] to _value_.
+ 1. Return _M_.
+ 1. Let _p_ be the Record {[[key]]: _key_, [[value]]: _value_}.
+ 1. Append _p_ as the last element of _entries_.
+ 1. Return _M_.
+
+
+
+
+
+
WeakMap.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"WeakMap"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of WeakMap Instances
+
WeakMap instances are ordinary objects that inherit properties from the WeakMap prototype. WeakMap instances also have a [[WeakMapData]] internal slot.
+
+
+
+
+
+
WeakSet Objects
+
WeakSet objects are collections of objects. A distinct object may only occur once as an element of a WeakSet's collection. A WeakSet may be queried to see if it contains a specific object, but no mechanism is provided for enumerating the objects it holds. If an object that is contained by a WeakSet is only reachable by following a chain of references that start within that WeakSet, then that object is inaccessible and is automatically removed from the WeakSet. WeakSet implementations must detect and remove such objects and any associated resources.
+
An implementation may impose an arbitrarily determined latency between the time an object contained in a WeakSet becomes inaccessible and the time when the object is removed from the WeakSet. If this latency was observable to ECMAScript program, it would be a source of indeterminacy that could impact program execution. For that reason, an ECMAScript implementation must not provide any means to determine if a WeakSet contains a particular object that does not require the observer to present the observed object.
+
WeakSet objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structure used in this WeakSet objects specification is only intended to describe the required observable semantics of WeakSet objects. It is not intended to be a viable implementation model.
+
+
See the NOTE in .
+
+
+
+
+
The WeakSet Constructor
+
The WeakSet constructor is the %WeakSet% intrinsic object and the initial value of the `WeakSet` property of the global object. When called as a constructor it creates and initializes a new WeakSet object. `WeakSet` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `WeakSet` constructor is designed to be subclassable. It may be used as the value in an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `WeakSet` behaviour must include a `super` call to the `WeakSet` constructor to create and initialize the subclass instance with the internal state necessary to support the `WeakSet.prototype` built-in methods.
+
+
+
+
WeakSet ( [ _iterable_ ] )
+
When the `WeakSet` function is called with optional argument _iterable_ the following steps are taken:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _set_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%WeakSetPrototype%"`, « [[WeakSetData]] » ).
+ 1. Set _set_'s [[WeakSetData]] internal slot to a new empty List.
+ 1. If _iterable_ is not present, let _iterable_ be *undefined*.
+ 1. If _iterable_ is either *undefined* or *null*, let _iter_ be *undefined*.
+ 1. Else,
+ 1. Let _adder_ be ? Get(_set_, `"add"`).
+ 1. If IsCallable(_adder_) is *false*, throw a *TypeError* exception.
+ 1. Let _iter_ be ? GetIterator(_iterable_).
+ 1. If _iter_ is *undefined*, return _set_.
+ 1. Repeat
+ 1. Let _next_ be ? IteratorStep(_iter_).
+ 1. If _next_ is *false*, return _set_.
+ 1. Let _nextValue_ be ? IteratorValue(_next_).
+ 1. Let _status_ be Call(_adder_, _set_, « _nextValue_ »).
+ 1. If _status_ is an abrupt completion, return IteratorClose(_iter_, _status_).
+
+
+
+
+
+
+
Properties of the WeakSet Constructor
+
The value of the [[Prototype]] internal slot of the WeakSet constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 0), the WeakSet constructor has the following properties:
+
+
+
+
WeakSet.prototype
+
The initial value of `WeakSet.prototype` is the intrinsic %WeakSetPrototype% object ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the WeakSet Prototype Object
+
The WeakSet prototype object is the intrinsic object %WeakSetPrototype%. The value of the [[Prototype]] internal slot of the WeakSet prototype object is the intrinsic object %ObjectPrototype% (). The WeakSet prototype object is an ordinary object. It does not have a [[WeakSetData]] internal slot.
+
+
+
+
WeakSet.prototype.add ( _value_ )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[WeakSetData]] internal slot, throw a *TypeError* exception.
+ 1. If Type(_value_) is not Object, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[WeakSetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. If _e_ is not ~empty~ and SameValue(_e_, _value_) is *true*, then
+ 1. Return _S_.
+ 1. Append _value_ as the last element of _entries_.
+ 1. Return _S_.
+
+
+
+
+
+
WeakSet.prototype.constructor
+
The initial value of `WeakSet.prototype.constructor` is the %WeakSet% intrinsic object.
+
+
+
+
+
WeakSet.prototype.delete ( _value_ )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[WeakSetData]] internal slot, throw a *TypeError* exception.
+ 1. If Type(_value_) is not Object, return *false*.
+ 1. Let _entries_ be the List that is the value of _S_'s [[WeakSetData]] internal slot.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. If _e_ is not ~empty~ and SameValue(_e_, _value_) is *true*, then
+ 1. Replace the element of _entries_ whose value is _e_ with an element whose value is ~empty~.
+ 1. Return *true*.
+ 1. Return *false*.
+
+
+
The value ~empty~ is used as a specification device to indicate that an entry has been deleted. Actual implementations may take other actions such as physically removing the entry from internal data structures.
+
+
+
+
+
+
WeakSet.prototype.has ( _value_ )
+
The following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. If Type(_S_) is not Object, throw a *TypeError* exception.
+ 1. If _S_ does not have a [[WeakSetData]] internal slot, throw a *TypeError* exception.
+ 1. Let _entries_ be the List that is the value of _S_'s [[WeakSetData]] internal slot.
+ 1. If Type(_value_) is not Object, return *false*.
+ 1. Repeat for each _e_ that is an element of _entries_,
+ 1. If _e_ is not ~empty~ and SameValue(_e_, _value_) is *true*, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
WeakSet.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"WeakSet"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of WeakSet Instances
+
WeakSet instances are ordinary objects that inherit properties from the WeakSet prototype. WeakSet instances also have a [[WeakSetData]] internal slot.
The abstract operation AllocateArrayBuffer with arguments _constructor_ and _byteLength_ is used to create an ArrayBuffer object. It performs the following steps:
+
+ 1. Let _obj_ be ? OrdinaryCreateFromConstructor(_constructor_, `"%ArrayBufferPrototype%"`, « [[ArrayBufferData]], [[ArrayBufferByteLength]] » ).
+ 1. Assert: _byteLength_ is a positive integer.
+ 1. Let _block_ be ? CreateByteDataBlock(_byteLength_).
+ 1. Set _obj_'s [[ArrayBufferData]] internal slot to _block_.
+ 1. Set _obj_'s [[ArrayBufferByteLength]] internal slot to _byteLength_.
+ 1. Return _obj_.
+
+
+
+
+
+
IsDetachedBuffer( _arrayBuffer_ )
+
The abstract operation IsDetachedBuffer with argument _arrayBuffer_ performs the following steps:
+
+ 1. Assert: Type(_arrayBuffer_) is Object and it has an [[ArrayBufferData]] internal slot.
+ 1. If _arrayBuffer_'s [[ArrayBufferData]] internal slot is *null*, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
DetachArrayBuffer( _arrayBuffer_ )
+
The abstract operation DetachArrayBuffer with argument _arrayBuffer_ performs the following steps:
+
+ 1. Assert: Type(_arrayBuffer_) is Object and it has [[ArrayBufferData]] and [[ArrayBufferByteLength]] internal slots.
+ 1. Set _arrayBuffer_'s [[ArrayBufferData]] internal slot to *null*.
+ 1. Set _arrayBuffer_'s [[ArrayBufferByteLength]] internal slot to 0.
+ 1. Return NormalCompletion(*null*).
+
+
+
Detaching an ArrayBuffer instance disassociates the Data Block used as its backing store from the instance and sets the byte length of the buffer to 0. No operations defined by this specification use the DetachArrayBuffer abstract operation. However, an ECMAScript implementation or host environment may define such operations.
The abstract operation CloneArrayBuffer takes three parameters, an ArrayBuffer _srcBuffer_, an integer _srcByteOffset_ and optionally a constructor function _cloneConstructor_. It creates a new ArrayBuffer whose data is a copy of _srcBuffer_'s data starting at _srcByteOffset_. This operation performs the following steps:
+
+ 1. Assert: Type(_srcBuffer_) is Object and it has an [[ArrayBufferData]] internal slot.
+ 1. If _cloneConstructor_ is not present, then
+ 1. Let _cloneConstructor_ be ? SpeciesConstructor(_srcBuffer_, %ArrayBuffer%).
+ 1. If IsDetachedBuffer(_srcBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Else, Assert: IsConstructor(_cloneConstructor_) is *true*.
+ 1. Let _srcLength_ be the value of _srcBuffer_'s [[ArrayBufferByteLength]] internal slot.
+ 1. Assert: _srcByteOffset_ ≤ _srcLength_.
+ 1. Let _cloneLength_ be _srcLength_ - _srcByteOffset_.
+ 1. Let _srcBlock_ be the value of _srcBuffer_'s [[ArrayBufferData]] internal slot.
+ 1. Let _targetBuffer_ be ? AllocateArrayBuffer(_cloneConstructor_, _cloneLength_).
+ 1. If IsDetachedBuffer(_srcBuffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _targetBlock_ be the value of _targetBuffer_'s [[ArrayBufferData]] internal slot.
+ 1. Perform CopyDataBlockBytes(_targetBlock_, 0, _srcBlock_, _srcByteOffset_, _cloneLength_).
+ 1. Return _targetBuffer_.
+
+
+
+
+
+
The abstract operation GetValueFromBuffer takes four parameters, an ArrayBuffer _arrayBuffer_, an integer _byteIndex_, a String _type_, and optionally a Boolean _isLittleEndian_. This operation performs the following steps:
+
+ 1. Assert: IsDetachedBuffer(_arrayBuffer_) is *false*.
+ 1. Assert: There are sufficient bytes in _arrayBuffer_ starting at _byteIndex_ to represent a value of _type_.
+ 1. Assert: _byteIndex_ is a positive integer.
+ 1. Let _block_ be _arrayBuffer_'s [[ArrayBufferData]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for Element Type _type_.
+ 1. Let _rawValue_ be a List of _elementSize_ containing, in order, the _elementSize_ sequence of bytes starting with _block_[_byteIndex_].
+ 1. If _isLittleEndian_ is not present, set _isLittleEndian_ to either *true* or *false*. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the SetValueInBuffer abstract operation.
+ 1. If _isLittleEndian_ is *false*, reverse the order of the elements of _rawValue_.
+ 1. If _type_ is `"Float32"`, then
+ 1. Let _value_ be the byte elements of _rawValue_ concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary32 value.
+ 1. If _value_ is an IEEE 754-2008 binary32 NaN value, return the *NaN* Number value.
+ 1. Return the Number value that corresponds to _value_.
+ 1. If _type_ is `"Float64"`, then
+ 1. Let _value_ be the byte elements of _rawValue_ concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary64 value.
+ 1. If _value_ is an IEEE 754-2008 binary64 NaN value, return the *NaN* Number value.
+ 1. Return the Number value that corresponds to _value_.
+ 1. If the first code unit of _type_ is `"U"`, then
+ 1. Let _intValue_ be the byte elements of _rawValue_ concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
+ 1. Else,
+ 1. Let _intValue_ be the byte elements of _rawValue_ concatenated and interpreted as a bit string encoding of a binary little-endian 2's complement number of bit length _elementSize_ × 8.
+ 1. Return the Number value that corresponds to _intValue_.
+
+
+
+
+
+
The abstract operation SetValueInBuffer takes five parameters, an ArrayBuffer _arrayBuffer_, an integer _byteIndex_, a String _type_, a Number _value_, and optionally a Boolean _isLittleEndian_. This operation performs the following steps:
+
+ 1. Assert: IsDetachedBuffer(_arrayBuffer_) is *false*.
+ 1. Assert: There are sufficient bytes in _arrayBuffer_ starting at _byteIndex_ to represent a value of _type_.
+ 1. Assert: _byteIndex_ is a positive integer.
+ 1. Assert: Type(_value_) is Number.
+ 1. Let _block_ be _arrayBuffer_'s [[ArrayBufferData]] internal slot.
+ 1. Assert: _block_ is not *undefined*.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for Element Type _type_.
+ 1. If _isLittleEndian_ is not present, set _isLittleEndian_ to either *true* or *false*. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the GetValueFromBuffer abstract operation.
+ 1. If _type_ is `"Float32"`, then
+ 1. Set _rawBytes_ to a List containing the 4 bytes that are the result of converting _value_ to IEEE 754-2008 binary32 format using “Round to nearest, ties to even” rounding mode. If _isLittleEndian_ is *false*, the bytes are arranged in big endian order. Otherwise, the bytes are arranged in little endian order. If _value_ is *NaN*, _rawValue_ may be set to any implementation chosen IEEE 754-2008 binary64 format Not-a-Number encoding. An implementation must always choose the same encoding for each implementation distinguishable *NaN* value.
+ 1. Else, if _type_ is `"Float64"`, then
+ 1. Set _rawBytes_ to a List containing the 8 bytes that are the IEEE 754-2008 binary64 format encoding of _value_. If _isLittleEndian_ is *false*, the bytes are arranged in big endian order. Otherwise, the bytes are arranged in little endian order. If _value_ is *NaN*, _rawValue_ may be set to any implementation chosen IEEE 754-2008 binary32 format Not-a-Number encoding. An implementation must always choose the same encoding for each implementation distinguishable *NaN* value.
+ 1. Else,
+ 1. Let _n_ be the Number value of the Element Size specified in for Element Type _type_.
+ 1. Let _convOp_ be the abstract operation named in the Conversion Operation column in for Element Type _type_.
+ 1. Let _intValue_ be _convOp_(_value_).
+ 1. If _intValue_ ≥ 0, then
+ 1. Let _rawBytes_ be a List containing the _n_-byte binary encoding of _intValue_. If _isLittleEndian_ is *false*, the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
+ 1. Else,
+ 1. Let _rawBytes_ be a List containing the _n_-byte binary 2's complement encoding of _intValue_. If _isLittleEndian_ is *false*, the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
+ 1. Store the individual bytes of _rawBytes_ into _block_, in order, starting at _block_[_byteIndex_].
+ 1. Return NormalCompletion(*undefined*).
+
+
+
+
+
+
+
The ArrayBuffer Constructor
+
The ArrayBuffer constructor is the %ArrayBuffer% intrinsic object and the initial value of the `ArrayBuffer` property of the global object. When called as a constructor it creates and initializes a new ArrayBuffer object. `ArrayBuffer` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `ArrayBuffer` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `ArrayBuffer` behaviour must include a `super` call to the `ArrayBuffer` constructor to create and initialize subclass instances with the internal state necessary to support the `ArrayBuffer.prototype` built-in methods.
+
+
+
+
ArrayBuffer( _length_ )
+
ArrayBuffer called with argument _length_ performs the following steps:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Let _numberLength_ be ToNumber(_length_).
+ 1. Let _byteLength_ be ? ToLength(_numberLength_).
+ 1. If SameValueZero(_numberLength_, _byteLength_) is *false*, throw a *RangeError* exception.
+ 1. Return AllocateArrayBuffer(NewTarget, _byteLength_).
+
+
+
+
+
+
+
Properties of the ArrayBuffer Constructor
+
The value of the [[Prototype]] internal slot of the ArrayBuffer constructor is the intrinsic object %FunctionPrototype% ().
+
Besides its `length` property (whose value is 1), the ArrayBuffer constructor has the following properties:
+
+
+
+
ArrayBuffer.isView ( _arg_ )
+
The isView function takes one argument _arg_, and performs the following steps are taken:
+
+ 1. If Type(_arg_) is not Object, return *false*.
+ 1. If _arg_ has a [[ViewedArrayBuffer]] internal slot, return *true*.
+ 1. Return *false*.
+
+
+
+
+
+
ArrayBuffer.prototype
+
The initial value of ArrayBuffer.prototype is the intrinsic object %ArrayBufferPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
get ArrayBuffer [ @@species ]
+
`ArrayBuffer[@@species]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
ArrayBuffer prototype methods normally use their `this` object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.
+
+
+
+
+
+
+
Properties of the ArrayBuffer Prototype Object
+
The ArrayBuffer prototype object is the intrinsic object %ArrayBufferPrototype%. The value of the [[Prototype]] internal slot of the ArrayBuffer prototype object is the intrinsic object %ObjectPrototype% (). The ArrayBuffer prototype object is an ordinary object. It does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] internal slot.
+
+
+
+
get ArrayBuffer.prototype.byteLength
+
`ArrayBuffer.prototype.byteLength` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have an [[ArrayBufferData]] internal slot, throw a *TypeError* exception.
+ 1. If IsDetachedBuffer(_O_) is *true*, throw a *TypeError* exception.
+ 1. Let _length_ be the value of _O_'s [[ArrayBufferByteLength]] internal slot.
+ 1. Return _length_.
+
+
+
+
+
+
ArrayBuffer.prototype.constructor
+
The initial value of `ArrayBuffer.prototype.constructor` is the intrinsic object %ArrayBuffer%.
+
+
+
+
+
ArrayBuffer.prototype.slice ( _start_, _end_ )
+
The following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have an [[ArrayBufferData]] internal slot, throw a *TypeError* exception.
+ 1. If IsDetachedBuffer(_O_) is *true*, throw a *TypeError* exception.
+ 1. Let _len_ be the value of _O_'s [[ArrayBufferByteLength]] internal slot.
+ 1. Let _relativeStart_ be ? ToInteger(_start_).
+ 1. If _relativeStart_ < 0, let _first_ be max((_len_ + _relativeStart_),0); else let _first_ be min(_relativeStart_, _len_).
+ 1. If _end_ is *undefined*, let _relativeEnd_ be _len_; else let _relativeEnd_ be ? ToInteger(_end_).
+ 1. If _relativeEnd_ < 0, let _final_ be max((_len_ + _relativeEnd_),0); else let _final_ be min(_relativeEnd_, _len_).
+ 1. Let _newLen_ be max(_final_-_first_,0).
+ 1. Let _ctor_ be ? SpeciesConstructor(_O_, %ArrayBuffer%).
+ 1. Let _new_ be ? Construct(_ctor_, « _newLen_ »).
+ 1. If _new_ does not have an [[ArrayBufferData]] internal slot, throw a *TypeError* exception.
+ 1. If IsDetachedBuffer(_new_) is *true*, throw a *TypeError* exception.
+ 1. If SameValue(_new_, _O_) is *true*, throw a *TypeError* exception.
+ 1. If the value of _new_'s [[ArrayBufferByteLength]] internal slot < _newLen_, throw a *TypeError* exception.
+ 1. NOTE: Side-effects of the above steps may have detached _O_.
+ 1. If IsDetachedBuffer(_O_) is *true*, throw a *TypeError* exception.
+ 1. Let _fromBuf_ be the value of _O_'s [[ArrayBufferData]] internal slot.
+ 1. Let _toBuf_ be the value of _new_'s [[ArrayBufferData]] internal slot.
+ 1. Perform CopyDataBlockBytes(_toBuf_, 0, _fromBuf_, _first_, _newLen_).
+ 1. Return _new_.
+
+
+
+
+
+
ArrayBuffer.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"ArrayBuffer"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of the ArrayBuffer Instances
+
ArrayBuffer instances inherit properties from the ArrayBuffer prototype object. ArrayBuffer instances each have an [[ArrayBufferData]] internal slot and an [[ArrayBufferByteLength]] internal slot.
+
ArrayBuffer instances whose [[ArrayBufferData]] is *null* are considered to be detached and all operators to access or modify data contained in the ArrayBuffer instance will fail.
The abstract operation GetViewValue with arguments _view_, _requestIndex_, _isLittleEndian_, and _type_ is used by functions on DataView instances is to retrieve values from the view's buffer. It performs the following steps:
+
+ 1. If Type(_view_) is not Object, throw a *TypeError* exception.
+ 1. If _view_ does not have a [[DataView]] internal slot, throw a *TypeError* exception.
+ 1. Let _numberIndex_ be ToNumber(_requestIndex_).
+ 1. Let _getIndex_ be ? ToInteger(_numberIndex_).
+ 1. If _numberIndex_ ≠ _getIndex_ or _getIndex_ < 0, throw a *RangeError* exception.
+ 1. Let _isLittleEndian_ be ToBoolean(_isLittleEndian_).
+ 1. Let _buffer_ be the value of _view_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _viewOffset_ be the value of _view_'s [[ByteOffset]] internal slot.
+ 1. Let _viewSize_ be the value of _view_'s [[ByteLength]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for Element Type _type_.
+ 1. If _getIndex_ +_elementSize_ > _viewSize_, throw a *RangeError* exception.
+ 1. Let _bufferIndex_ be _getIndex_ + _viewOffset_.
+ 1. Return GetValueFromBuffer(_buffer_, _bufferIndex_, _type_, _isLittleEndian_).
+
+
+
+
+
+
The abstract operation SetViewValue with arguments _view_, _requestIndex_, _isLittleEndian_, _type_, and _value_ is used by functions on DataView instances to store values into the view's buffer. It performs the following steps:
+
+ 1. If Type(_view_) is not Object, throw a *TypeError* exception.
+ 1. If _view_ does not have a [[DataView]] internal slot, throw a *TypeError* exception.
+ 1. Let _numberIndex_ be ToNumber(_requestIndex_).
+ 1. Let _getIndex_ be ? ToInteger(_numberIndex_).
+ 1. If _numberIndex_ ≠ _getIndex_ or _getIndex_ < 0, throw a *RangeError* exception.
+ 1. Let _numberValue_ be ? ToNumber(_value_).
+ 1. Let _isLittleEndian_ be ToBoolean(_isLittleEndian_).
+ 1. Let _buffer_ be the value of _view_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _viewOffset_ be the value of _view_'s [[ByteOffset]] internal slot.
+ 1. Let _viewSize_ be the value of _view_'s [[ByteLength]] internal slot.
+ 1. Let _elementSize_ be the Number value of the Element Size value specified in for Element Type _type_.
+ 1. If _getIndex_ +_elementSize_ > _viewSize_, throw a *RangeError* exception.
+ 1. Let _bufferIndex_ be _getIndex_ + _viewOffset_.
+ 1. Return SetValueInBuffer(_buffer_, _bufferIndex_, _type_, _numberValue_, _isLittleEndian_).
+
+
+
+
+
+
+
The DataView Constructor
+
The DataView constructor is the %DataView% intrinsic object and the initial value of the `DataView` property of the global object. When called as a constructor it creates and initializes a new DataView object. `DataView` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `DataView` constructor is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `DataView` behaviour must include a `super` call to the `DataView` constructor to create and initialize subclass instances with the internal state necessary to support the `DataView.prototype` built-in methods.
`DataView` called with arguments _buffer_, _byteOffset_, and _length_ performs the following steps:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. If Type(_buffer_) is not Object, throw a *TypeError* exception.
+ 1. If _buffer_ does not have an [[ArrayBufferData]] internal slot, throw a *TypeError* exception.
+ 1. Let _numberOffset_ be ToNumber(_byteOffset_).
+ 1. Let _offset_ be ? ToInteger(_numberOffset_).
+ 1. If _numberOffset_ ≠ _offset_ or _offset_ < 0, throw a *RangeError* exception.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _bufferByteLength_ be the value of _buffer_'s [[ArrayBufferByteLength]] internal slot.
+ 1. If _offset_ > _bufferByteLength_, throw a *RangeError* exception.
+ 1. If _byteLength_ is *undefined*, then
+ 1. Let _viewByteLength_ be _bufferByteLength_ - _offset_.
+ 1. Else,
+ 1. Let _viewByteLength_ be ? ToLength(_byteLength_).
+ 1. If _offset_+_viewByteLength_ > _bufferByteLength_, throw a *RangeError* exception.
+ 1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%DataViewPrototype%"`, « [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]] » ).
+ 1. Set _O_'s [[DataView]] internal slot to *true*.
+ 1. Set _O_'s [[ViewedArrayBuffer]] internal slot to _buffer_.
+ 1. Set _O_'s [[ByteLength]] internal slot to _viewByteLength_.
+ 1. Set _O_'s [[ByteOffset]] internal slot to _offset_.
+ 1. Return _O_.
+
+
+
+
+
+
+
Properties of the DataView Constructor
+
The value of the [[Prototype]] internal slot of the `DataView` constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 3), the DataView constructor has the following properties:
+
+
+
+
DataView.prototype
+
The initial value of `DataView.prototype` is the intrinsic object %DataViewPrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the DataView Prototype Object
+
The DataView prototype object is the intrinsic object %DataViewPrototype%. The value of the [[Prototype]] internal slot of the DataView prototype object is the intrinsic object %ObjectPrototype% (). The DataView prototype object is an ordinary object. It does not have a [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], or [[ByteOffset]] internal slot.
+
+
+
+
get DataView.prototype.buffer
+
`DataView.prototype.buffer` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. Return _buffer_.
+
+
+
+
+
+
get DataView.prototype.byteLength
+
`DataView`.`prototype.byteLength` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _size_ be the value of _O_'s [[ByteLength]] internal slot.
+ 1. Return _size_.
+
+
+
+
+
+
get DataView.prototype.byteOffset
+
`DataView`.`prototype.byteOffset` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object, throw a *TypeError* exception.
+ 1. If _O_ does not have a [[ViewedArrayBuffer]] internal slot, throw a *TypeError* exception.
+ 1. Let _buffer_ be the value of _O_'s [[ViewedArrayBuffer]] internal slot.
+ 1. If IsDetachedBuffer(_buffer_) is *true*, throw a *TypeError* exception.
+ 1. Let _offset_ be the value of _O_'s [[ByteOffset]] internal slot.
+ 1. Return _offset_.
+
+
+
+
+
+
DataView.prototype.constructor
+
The initial value of `DataView.prototype.constructor` is the intrinsic object %DataView%.
When the `getFloat32` method is called with argument _byteOffset_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return GetViewValue(_v_, _byteOffset_, _littleEndian_, `"Float32"`).
+
+
+
+
+
+
When the `getFloat64` method is called with argument _byteOffset_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return GetViewValue(_v_, _byteOffset_, _littleEndian_, `"Float64"`).
+
+
+
+
+
+
DataView.prototype.getInt8 ( _byteOffset_ )
+
When the `getInt8` method is called with argument _byteOffset_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. Return GetViewValue(_v_, _byteOffset_, *true*, `"Int8"`).
+
+
+
+
+
+
When the `getInt16` method is called with argument _byteOffset_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return GetViewValue(_v_, _byteOffset_, _littleEndian_, `"Int16"`).
+
+
+
+
+
+
When the `getInt32` method is called with argument _byteOffset_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *undefined*.
+ 1. Return GetViewValue(_v_, _byteOffset_, _littleEndian_, `"Int32"`).
+
+
+
+
+
+
DataView.prototype.getUint8 ( _byteOffset_ )
+
When the `getUint8` method is called with argument _byteOffset_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. Return GetViewValue(_v_, _byteOffset_, *true*, `"Uint8"`).
+
+
+
+
+
+
When the `getUint16` method is called with argument _byteOffset_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return GetViewValue(_v_, _byteOffset_, _littleEndian_, `"Uint16"`).
+
+
+
+
+
+
When the `getUint32` method is called with argument _byteOffset_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return GetViewValue(_v_, _byteOffset_, _littleEndian_, `"Uint32"`).
+
+
+
+
+
+
When the `setFloat32` method is called with arguments _byteOffset_ and _value_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return SetViewValue(_v_, _byteOffset_, _littleEndian_, `"Float32"`, _value_).
+
+
+
+
+
+
When the `setFloat64` method is called with arguments _byteOffset_ and _value_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return SetViewValue(_v_, _byteOffset_, _littleEndian_, `"Float64"`, _value_).
+
+
+
+
+
+
When the `setInt16` method is called with arguments _byteOffset_ and _value_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return SetViewValue(_v_, _byteOffset_, _littleEndian_, `"Int16"`, _value_).
+
+
+
+
+
+
When the `setInt32` method is called with arguments _byteOffset_ and _value_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return SetViewValue(_v_, _byteOffset_, _littleEndian_, `"Int32"`, _value_).
+
+
+
+
+
+
When the `setUint16` method is called with arguments _byteOffset_ and _value_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return SetViewValue(_v_, _byteOffset_, _littleEndian_, `"Uint16"`, _value_).
+
+
+
+
+
+
When the `setUint32` method is called with arguments _byteOffset_ and _value_ and optional argument _littleEndian_ the following steps are taken:
+
+ 1. Let _v_ be the *this* value.
+ 1. If _littleEndian_ is not present, let _littleEndian_ be *false*.
+ 1. Return SetViewValue(_v_, _byteOffset_, _littleEndian_, `"Uint32"`, _value_).
+
+
+
+
+
+
DataView.prototype[ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"DataView"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of DataView Instances
+
DataView instances are ordinary objects that inherit properties from the DataView prototype object. DataView instances each have [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], and [[ByteOffset]] internal slots.
+
+
The value of the [[DataView]] internal slot is not used within this specification. The simple presence of that internal slot is used within the specification to identify objects created using the `DataView` constructor.
+
+
+
+
+
+
+
The JSON Object
+
The JSON object is the %JSON% intrinsic object and the initial value of the `JSON` property of the global object. The JSON object is a single ordinary object that contains two functions, `parse` and `stringify`, that are used to parse and construct JSON texts. The JSON Data Interchange Format is defined in ECMA-404. The JSON interchange format used in this specification is exactly that described by ECMA-404.
+
Conforming implementations of `JSON.parse` and `JSON.stringify` must support the exact interchange format described in the ECMA-404 specification without any deletions or extensions to the format.
+
The value of the [[Prototype]] internal slot of the JSON object is the intrinsic object %ObjectPrototype% (). The value of the [[Extensible]] internal slot of the JSON object is set to *true*.
+
The JSON object does not have a [[Construct]] internal method; it is not possible to use the JSON object as a constructor with the `new` operator.
+
The JSON object does not have a [[Call]] internal method; it is not possible to invoke the JSON object as a function.
+
+
+
+
JSON.parse ( _text_ [ , _reviver_ ] )
+
The `parse` function parses a JSON text (a JSON-formatted String) and produces an ECMAScript value. The JSON format is a subset of the syntax for ECMAScript literals, Array Initializers and Object Initializers. After parsing, JSON objects are realized as ECMAScript objects. JSON arrays are realized as ECMAScript Array instances. JSON strings, numbers, booleans, and null are realized as ECMAScript Strings, Numbers, Booleans, and *null*.
+
The optional _reviver_ parameter is a function that takes two parameters, _key_ and _value_. It can filter and transform the results. It is called with each of the _key_/_value_ pairs produced by the parse, and its return value is used instead of the original value. If it returns what it received, the structure is not modified. If it returns *undefined* then the property is deleted from the result.
+
+ 1. Let _JText_ be ? ToString(_text_).
+ 1. Parse _JText_ interpreted as UTF-16 encoded Unicode points () as a JSON text as specified in ECMA-404. Throw a *SyntaxError* exception if _JText_ is not a valid JSON text as defined in that specification.
+ 1. Let _scriptText_ be the result of concatenating `"("`, _JText_, and `");"`.
+ 1. Let _completion_ be the result of parsing and evaluating _scriptText_ as if it was the source text of an ECMAScript |Script|. but using the alternative definition of |DoubleStringCharacter| provided below. The extended PropertyDefinitionEvaluation semantics defined in must not be used during the evaluation.
+ 1. Let _unfiltered_ be _completion_.[[value]].
+ 1. Assert: _unfiltered_ will be either a primitive value or an object that is defined by either an |ArrayLiteral| or an |ObjectLiteral|.
+ 1. If IsCallable(_reviver_) is *true*, then
+ 1. Let _root_ be ObjectCreate(%ObjectPrototype%).
+ 1. Let _rootName_ be the empty String.
+ 1. Let _status_ be CreateDataProperty(_root_, _rootName_, _unfiltered_).
+ 1. Assert: _status_ is *true*.
+ 1. Return InternalizeJSONProperty(_root_, _rootName_).
+ 1. Else,
+ 1. Return _unfiltered_.
+
+
JSON allows Unicode code units 0x2028 (LINE SEPARATOR) and 0x2029 (PARAGRAPH SEPARATOR) to directly appear in String literals without using an escape sequence. This is enabled by using the following alternative definition of |DoubleStringCharacter| when parsing _scriptText_ in step 4:
+
+ DoubleStringCharacter ::
+ SourceCharacter but not one of `"` or `\` or U+0000 through U+001F
+ `\` EscapeSequence
+
+
+
+ The SV of DoubleStringCharacter :: SourceCharacter but not one of `"` or `\` or U+0000 through U+001F is the UTF16Encoding () of the code point value of |SourceCharacter|.
+
+
+
+
The syntax of a valid JSON text is a subset of the ECMAScript |PrimaryExpression| syntax. Hence a valid JSON text is also a valid |PrimaryExpression|. Step 2 above verifies that _JText_ conforms to that subset. When _scriptText_ is parsed and evaluated as a |Script| the result will be either a String, Number, Boolean, or Null primitive value or an Object defined as if by an |ArrayLiteral| or |ObjectLiteral|.
The abstract operation InternalizeJSONProperty is a recursive abstract operation that takes two parameters: a _holder_ object and the String _name_ of a property in that object. InternalizeJSONProperty uses the value of _reviver_ that was originally passed to the above parse function.
+
+ 1. Let _val_ be ? Get(_holder_, _name_).
+ 1. If Type(_val_) is Object, then
+ 1. Let _isArray_ be ? IsArray(_val_).
+ 1. If _isArray_ is *true*, then
+ 1. Set _I_ to 0.
+ 1. Let _len_ be ? ToLength(? Get(_val_, `"length"`)).
+ 1. Repeat while _I_ < _len_,
+ 1. Let _newElement_ be ? InternalizeJSONProperty(_val_, ToString(_I_)).
+ 1. If _newElement_ is *undefined*, then
+ 1. Let _status_ be _val_.[[Delete]](ToString(_I_)).
+ 1. Else,
+ 1. Let _status_ be CreateDataProperty(_val_, ToString(_I_), _newElement_).
+ 1. NOTE This algorithm intentionally does not throw an exception if status is *false*.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Add 1 to _I_.
+ 1. Else,
+ 1. Let _keys_ be ? EnumerableOwnNames(_val_).
+ 1. For each String _P_ in _keys_ do,
+ 1. Let _newElement_ be ? InternalizeJSONProperty(_val_, _P_).
+ 1. If _newElement_ is *undefined*, then
+ 1. Let _status_ be _val_.[[Delete]](_P_).
+ 1. Else,
+ 1. Let _status_ be CreateDataProperty(_val_, _P_, _newElement_).
+ 1. NOTE This algorithm intentionally does not throw an exception if status is *false*.
+ 1. ReturnIfAbrupt(_status_).
+ 1. Return Call(_reviver_, _holder_, « _name_, _val_ »).
+
+
It is not permitted for a conforming implementation of `JSON.parse` to extend the JSON grammars. If an implementation wishes to support a modified or extended JSON interchange format it must do so by defining a different parse function.
+
+
In the case where there are duplicate name Strings within an object, lexically preceding values for the same key shall be overwritten.
The `stringify` function returns a String in UTF-16 encoded JSON format representing an ECMAScript value. It can take three parameters. The _value_ parameter is an ECMAScript value, which is usually an object or array, although it can also be a String, Boolean, Number or *null*. The optional _replacer_ parameter is either a function that alters the way objects and arrays are stringified, or an array of Strings and Numbers that acts as a white list for selecting the object properties that will be stringified. The optional _space_ parameter is a String or Number that allows the result to have white space injected into it to improve human readability.
+
These are the steps in stringifying an object:
+
+ 1. Let _stack_ be an empty List.
+ 1. Let _indent_ be the empty String.
+ 1. Let _PropertyList_ and _ReplacerFunction_ be *undefined*.
+ 1. If Type(_replacer_) is Object, then
+ 1. If IsCallable(_replacer_) is *true*, then
+ 1. Let _ReplacerFunction_ be _replacer_.
+ 1. Else,
+ 1. Let _isArray_ be ? IsArray(_replacer_).
+ 1. If _isArray_ is *true*, then
+ 1. Let _PropertyList_ be an empty List.
+ 1. Let _len_ be ? ToLength(? Get(_replacer_, `"length"`)).
+ 1. Let _k_ be 0.
+ 1. Repeat while _k_<_len_.
+ 1. Let _v_ be ? Get(_replacer_, ToString(_k_)).
+ 1. Let _item_ be *undefined*.
+ 1. If Type(_v_) is String, let _item_ be _v_.
+ 1. Else if Type(_v_) is Number, let _item_ be ToString(_v_).
+ 1. Else if Type(_v_) is Object, then
+ 1. If _v_ has a [[StringData]] or [[NumberData]] internal slot, let _item_ be ? ToString(_v_).
+ 1. If _item_ is not *undefined* and _item_ is not currently an element of _PropertyList_, then
+ 1. Append _item_ to the end of _PropertyList_.
+ 1. Let _k_ be _k_+1.
+ 1. If Type(_space_) is Object, then
+ 1. If _space_ has a [[NumberData]] internal slot, then
+ 1. Let _space_ be ? ToNumber(_space_).
+ 1. Else if _space_ has a [[StringData]] internal slot, then
+ 1. Let _space_ be ? ToString(_space_).
+ 1. If Type(_space_) is Number, then
+ 1. Let _space_ be min(10, ToInteger(_space_)).
+ 1. Set _gap_ to a String containing _space_ occurrences of code unit 0x0020 (SPACE). This will be the empty String if _space_ is less than 1.
+ 1. Else if Type(_space_) is String, then
+ 1. If the number of elements in _space_ is 10 or less, set _gap_ to _space_ otherwise set _gap_ to a String consisting of the first 10 elements of _space_.
+ 1. Else,
+ 1. Set _gap_ to the empty String.
+ 1. Let _wrapper_ be ObjectCreate(%ObjectPrototype%).
+ 1. Let _status_ be CreateDataProperty(_wrapper_, the empty String, _value_).
+ 1. Assert: _status_ is *true*.
+ 1. Return SerializeJSONProperty(the empty String, _wrapper_).
+
+
+
JSON structures are allowed to be nested to any depth, but they must be acyclic. If _value_ is or contains a cyclic structure, then the stringify function must throw a *TypeError* exception. This is an example of a value that cannot be stringified:
+
+a = [];
+a[0] = a;
+my_text = JSON.stringify(a); // This must throw a TypeError.
+
+
+
+
Symbolic primitive values are rendered as follows:
+
+
+ The *null* value is rendered in JSON text as the String `null`.
+
+
+ The *undefined* value is not rendered.
+
+
+ The *true* value is rendered in JSON text as the String `true`.
+
+
+ The *false* value is rendered in JSON text as the String `false`.
+
+
+
+
+
String values are wrapped in QUOTATION MARK (`"`) code units. The code units `"` and `\\` are escaped with `\\` prefixes. Control characters code units are replaced with escape sequences `\\u`HHHH, or with the shorter forms, `\\b` (BACKSPACE), `\\f` (FORM FEED), `\\n` (LINE FEED), `\\r` (CARRIAGE RETURN), `\\t` (CHARACTER TABULATION).
+
+
+
Finite numbers are stringified as if by calling ToString(_number_). *NaN* and Infinity regardless of sign are represented as the String `null`.
+
+
+
Values that do not have a JSON representation (such as *undefined* and functions) do not produce a String. Instead they produce the *undefined* value. In arrays these values are represented as the String `null`. In objects an unrepresentable value causes the property to be excluded from stringification.
+
+
+
An object is rendered as U+007B (LEFT CURLY BRACKET) followed by zero or more properties, separated with a U+002C (COMMA), closed with a U+007D (RIGHT CURLY BRACKET). A property is a quoted String representing the key or property name, a U+003A (COLON), and then the stringified property value. An array is rendered as an opening U+005B (LEFT SQUARE BRACKET followed by zero or more values, separated with a U+002C (COMMA), closed with a U+005D (RIGHT SQUARE BRACKET).
The abstract operation SerializeJSONProperty with arguments _key_, and _holder_ has access to _ReplacerFunction_ from the invocation of the `stringify` method. Its algorithm is as follows:
+
+ 1. Let _value_ be ? Get(_holder_, _key_).
+ 1. If Type(_value_) is Object, then
+ 1. Let _toJSON_ be ? Get(_value_, `"toJSON"`).
+ 1. If IsCallable(_toJSON_) is *true*, then
+ 1. Let _value_ be ? Call(_toJSON_, _value_, « _key_ »).
+ 1. If _ReplacerFunction_ is not *undefined*, then
+ 1. Let _value_ be ? Call(_ReplacerFunction_, _holder_, « _key_, _value_ »).
+ 1. If Type(_value_) is Object, then
+ 1. If _value_ has a [[NumberData]] internal slot, then
+ 1. Let _value_ be ? ToNumber(_value_).
+ 1. Else if _value_ has a [[StringData]] internal slot, then
+ 1. Let _value_ be ? ToString(_value_).
+ 1. Else if _value_ has a [[BooleanData]] internal slot, then
+ 1. Let _value_ be the value of the [[BooleanData]] internal slot of _value_.
+ 1. If _value_ is *null*, return `"null"`.
+ 1. If _value_ is *true*, return `"true"`.
+ 1. If _value_ is *false*, return `"false"`.
+ 1. If Type(_value_) is String, return QuoteJSONString(_value_).
+ 1. If Type(_value_) is Number, then
+ 1. If _value_ is finite, return ToString(_value_).
+ 1. Else, return `"null"`.
+ 1. If Type(_value_) is Object, and IsCallable(_value_) is *false*, then
+ 1. Let _isArray_ be ? IsArray(_value_).
+ 1. If _isArray_ is *true*, return SerializeJSONArray(_value_).
+ 1. Else, return SerializeJSONObject(_value_).
+ 1. Return *undefined*.
+
+
+
+
+
+
Runtime Semantics: QuoteJSONString ( _value_ )
+
The abstract operation QuoteJSONString with argument _value_ wraps a String value in QUOTATION MARK code units and escapes certain other code units within it.
+
+ 1. Let _product_ be code unit 0x0022 (QUOTATION MARK).
+ 1. For each code unit _C_ in _value_
+ 1. If _C_ is 0x0022 (QUOTATION MARK) or 0x005C (REVERSE SOLIDUS), then
+ 1. Let _product_ be the concatenation of _product_ and code unit 0x005C (REVERSE SOLIDUS).
+ 1. Let _product_ be the concatenation of _product_ and _C_.
+ 1. Else if _C_ is 0x0008 (BACKSPACE), 0x000C (FORM FEED), 0x000A (LINE FEED), 0x000D (CARRIAGE RETURN), or 0x0009 (CHARACTER TABULATION), then
+ 1. Let _product_ be the concatenation of _product_ and code unit 0x005C (REVERSE SOLIDUS).
+ 1. Let _abbrev_ be the String value corresponding to the value of _C_ as follows:
+
+
+
+
+ BACKSPACE
+
+
+ `"b"`
+
+
+
+
+ FORM FEED (FF)
+
+
+ `"f"`
+
+
+
+
+ LINE FEED (LF)
+
+
+ `"n"`
+
+
+
+
+ CARRIAGE RETURN (CR)
+
+
+ `"r"`
+
+
+
+
+ CHARACTER TABULATION
+
+
+ `"t"`
+
+
+
+
+ 1. Let _product_ be the concatenation of _product_ and _abbrev_.
+ 1. Else if _C_ has a code unit value less than 0x0020 (SPACE), then
+ 1. Let _product_ be the concatenation of _product_ and code unit 0x005C (REVERSE SOLIDUS).
+ 1. Let _product_ be the concatenation of _product_ and `"u"`.
+ 1. Let _hex_ be the string result of converting the numeric code unit value of _C_ to a String of four hexadecimal digits. Alphabetic hexadecimal digits are presented as lowercase Latin letters.
+ 1. Let _product_ be the concatenation of _product_ and _hex_.
+ 1. Else,
+ 1. Let _product_ be the concatenation of _product_ and _C_.
+ 1. Let _product_ be the concatenation of _product_ and code unit 0x0022 (QUOTATION MARK).
+ 1. Return _product_.
+
+
+
+
+
+
The abstract operation SerializeJSONObject with argument _value_ serializes an object. It has access to the _stack_, _indent_, _gap_, and _PropertyList_ values of the current invocation of the `stringify` method.
+
+ 1. If _stack_ contains _value_, throw a *TypeError* exception because the structure is cyclical.
+ 1. Append _value_ to _stack_.
+ 1. Let _stepback_ be _indent_.
+ 1. Let _indent_ be the concatenation of _indent_ and _gap_.
+ 1. If _PropertyList_ is not *undefined*, then
+ 1. Let _K_ be _PropertyList_.
+ 1. Else,
+ 1. Let _K_ be ? EnumerableOwnNames(_value_).
+ 1. Let _partial_ be an empty List.
+ 1. For each element _P_ of _K_,
+ 1. Let _strP_ be ? SerializeJSONProperty(_P_, _value_).
+ 1. If _strP_ is not *undefined*, then
+ 1. Let _member_ be QuoteJSONString(_P_).
+ 1. Let _member_ be the concatenation of _member_ and the string `":"`.
+ 1. If _gap_ is not the empty String, then
+ 1. Let _member_ be the concatenation of _member_ and code unit 0x0020 (SPACE).
+ 1. Let _member_ be the concatenation of _member_ and _strP_.
+ 1. Append _member_ to _partial_.
+ 1. If _partial_ is empty, then
+ 1. Let _final_ be `"{}"`.
+ 1. Else,
+ 1. If _gap_ is the empty String, then
+ 1. Let _properties_ be a String formed by concatenating all the element Strings of _partial_ with each adjacent pair of Strings separated with code unit 0x002C (COMMA). A comma is not inserted either before the first String or after the last String.
+ 1. Let _final_ be the result of concatenating `"{"`, _properties_, and `"}"`.
+ 1. Else _gap_ is not the empty String
+ 1. Let _separator_ be the result of concatenating code unit 0x002C (COMMA), code unit 0x000A (LINE FEED), and _indent_.
+ 1. Let _properties_ be a String formed by concatenating all the element Strings of _partial_ with each adjacent pair of Strings separated with _separator_. The _separator_ String is not inserted either before the first String or after the last String.
+ 1. Let _final_ be the result of concatenating `"{"`, code unit 0x000A (LINE FEED), _indent_, _properties_, code unit 0x000A, _stepback_, and `"}"`.
+ 1. Remove the last element of _stack_.
+ 1. Let _indent_ be _stepback_.
+ 1. Return _final_.
+
+
+
+
+
+
Runtime Semantics: SerializeJSONArray ( _value_ )
+
The abstract operation SerializeJSONArray with argument _value_ serializes an array. It has access to the _stack_, _indent_, and _gap_ values of the current invocation of the `stringify` method.
+
+ 1. If _stack_ contains _value_, throw a *TypeError* exception because the structure is cyclical.
+ 1. Append _value_ to _stack_.
+ 1. Let _stepback_ be _indent_.
+ 1. Let _indent_ be the concatenation of _indent_ and _gap_.
+ 1. Let _partial_ be an empty List.
+ 1. Let _len_ be ? ToLength(? Get(_value_, `"length"`)).
+ 1. Let _index_ be 0.
+ 1. Repeat while _index_ < _len_
+ 1. Let _strP_ be ? SerializeJSONProperty(ToString(_index_), _value_).
+ 1. If _strP_ is *undefined*, then
+ 1. Append `"null"` to _partial_.
+ 1. Else,
+ 1. Append _strP_ to _partial_.
+ 1. Increment _index_ by 1.
+ 1. If _partial_ is empty, then
+ 1. Let _final_ be `"[]"`.
+ 1. Else,
+ 1. If _gap_ is the empty String, then
+ 1. Let _properties_ be a String formed by concatenating all the element Strings of _partial_ with each adjacent pair of Strings separated with code unit 0x002C (COMMA). A comma is not inserted either before the first String or after the last String.
+ 1. Let _final_ be the result of concatenating `"["`, _properties_, and `"]"`.
+ 1. Else,
+ 1. Let _separator_ be the result of concatenating code unit 0x002C (COMMA), code unit 0x000A (LINE FEED), and _indent_.
+ 1. Let _properties_ be a String formed by concatenating all the element Strings of _partial_ with each adjacent pair of Strings separated with _separator_. The _separator_ String is not inserted either before the first String or after the last String.
+ 1. Let _final_ be the result of concatenating `"["`, code unit 0x000A (LINE FEED), _indent_, _properties_, code unit 0x000A, _stepback_, and `"]"`.
+ 1. Remove the last element of _stack_.
+ 1. Let _indent_ be _stepback_.
+ 1. Return _final_.
+
+
+
The representation of arrays includes only the elements between zero and `array.length` - 1 inclusive. Properties whose keys are not array indexes are excluded from the stringification. An array is stringified as an opening LEFT SQUARE BRACKET, elements separated by COMMA, and a closing RIGHT SQUARE BRACKET.
+
+
+
+
+
+
+
JSON [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"JSON"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
+
Control Abstraction Objects
+
+
+
+
Iteration
+
+
+
+
Common Iteration Interfaces
+
An interface is a set of property keys whose associated values match a specific specification. Any object that provides all the properties as described by an interface's specification conforms to that interface. An interface is not represented by a distinct object. There may be many separately implemented objects that conform to any interface. An individual object may conform to multiple interfaces.
+
+
+
+
The Iterable Interface
+
The Iterable interface includes the property described in :
+
+
+
+
+
+ Property
+
+
+ Value
+
+
+ Requirements
+
+
+
+
+ `@@iterator`
+
+
+ A function that returns an Iterator object.
+
+
+ The returned object must conform to the Iterator interface.
+
+
+
+
+
+
+
+
+
+
The Iterator Interface
+
An object that implements the Iterator interface must include the property in . Such objects may also implement the properties in .
+
+
+
+
+
+ Property
+
+
+ Value
+
+
+ Requirements
+
+
+
+
+ `next`
+
+
+ A function that returns an IteratorResult object.
+
+
+ The returned object must conform to the IteratorResult interface. If a previous call to the `next` method of an Iterator has returned an IteratorResult object whose `done` property is *true*, then all subsequent calls to the `next` method of that object should also return an IteratorResult object whose `done` property is *true*. However, this requirement is not enforced.
+
+
+
+
+
+
+
Arguments may be passed to the next function but their interpretation and validity is dependent upon the target Iterator. The for-of statement and other common users of Iterators do not pass any arguments, so Iterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.
+
+
+
+
+
+
+ Property
+
+
+ Value
+
+
+ Requirements
+
+
+
+
+ `return`
+
+
+ A function that returns an IteratorResult object.
+
+
+ The returned object must conform to the IteratorResult interface. Invoking this method notifies the Iterator object that the caller does not intend to make any more `next` method calls to the Iterator. The returned IteratorResult object will typically have a `done` property whose value is *true*, and a `value` property with the value passed as the argument of the `return` method. However, this requirement is not enforced.
+
+
+
+
+ `throw`
+
+
+ A function that returns an IteratorResult object.
+
+
+ The returned object must conform to the IteratorResult interface. Invoking this method notifies the Iterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an exception object. A typical response is to `throw` the value passed as the argument. If the method does not `throw`, the returned IteratorResult object will typically have a `done` property whose value is *true*.
+
+
+
+
+
+
+
Typically callers of these methods should check for their existence before invoking them. Certain ECMAScript language features including `for`-`of`, `yield*`, and array destructuring call these methods after performing an existence check. Most ECMAScript library functions that accept Iterable objects as arguments also conditionally call them.
+
+
+
+
+
+
The IteratorResult Interface
+
The IteratorResult interface includes the properties listed in :
+
+
+
+
+
+ Property
+
+
+ Value
+
+
+ Requirements
+
+
+
+
+ `done`
+
+
+ Either *true* or *false*.
+
+
+ This is the result status of an iterator `next` method call. If the end of the iterator was reached `done` is *true*. If the end was not reached `done` is *false* and a value is available. If a `done` property (either own or inherited) does not exist, it is consider to have the value *false*.
+
+
+
+
+ `value`
+
+
+ Any ECMAScript language value.
+
+
+ If done is *false*, this is the current iteration element value. If done is *true*, this is the return value of the iterator, if it supplied one. If the iterator does not have a return value, `value` is *undefined*. In that case, the `value` property may be absent from the conforming object if it does not inherit an explicit `value` property.
+
+
+
+
+
+
+
+
+
+
+
The %IteratorPrototype% Object
+
The value of the [[Prototype]] internal slot of the %IteratorPrototype% object is the intrinsic object %ObjectPrototype% (). The %IteratorPrototype% object is an ordinary object. The initial value of the [[Extensible]] internal slot of the %IteratorPrototype% object is *true*.
+
+
All objects defined in this specification that implement the Iterator interface also inherit from %IteratorPrototype%. ECMAScript code may also define objects that inherit from %IteratorPrototype%.The %IteratorPrototype% object provides a place where additional methods that are applicable to all iterator objects may be added.
+
The following expression is one way that ECMAScript code can access the %IteratorPrototype% object:
The value of the `name` property of this function is `"[Symbol.iterator]"`.
+
+
+
+
+
+
+
GeneratorFunction Objects
+
Generator Function objects are functions that are usually created by evaluating |GeneratorDeclaration|, |GeneratorExpression|, and |GeneratorMethod| syntactic productions. They may also be created by calling the %GeneratorFunction% intrinsic.
+
+
+
+
+
+
+
The GeneratorFunction Constructor
+
The `GeneratorFunction` constructor is the %GeneratorFunction% intrinsic. When `GeneratorFunction` is called as a function rather than as a constructor, it creates and initializes a new GeneratorFunction object. Thus the function call `GeneratorFunction (…)` is equivalent to the object creation expression `new GeneratorFunction (…)` with the same arguments.
+
`GeneratorFunction` is designed to be subclassable. It may be used as the value of an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `GeneratorFunction` behaviour must include a `super` call to the `GeneratorFunction` constructor to create and initialize subclass instances with the internal slots necessary for built-in GeneratorFunction behaviour. All ECMAScript syntactic forms for defining generator function objects create direct instances of `GeneratorFunction`. There is no syntactic means to create instances of `GeneratorFunction` subclasses.
+
+
+
+
GeneratorFunction (_p1_, _p2_, … , _pn_, _body_)
+
The last argument specifies the body (executable code) of a generator function; any preceding arguments specify formal parameters.
+
When the `GeneratorFunction` function is called with some arguments _p1_, _p2_, … , _pn_, _body_ (where _n_ might be 0, that is, there are no “_p_” arguments, and where _body_ might also not be provided), the following steps are taken:
+
+ 1. Let _C_ be the active function object.
+ 1. Let _args_ be the _argumentsList_ that was passed to this function by [[Call]] or [[Construct]].
+ 1. Return CreateDynamicFunction(_C_, NewTarget, `"generator"`, _args_).
+
+
+
See NOTE for .
+
+
+
+
+
+
+
Properties of the GeneratorFunction Constructor
+
The `GeneratorFunction` constructor is a standard built-in function object that inherits from the `Function` constructor. The value of the [[Prototype]] internal slot of the `GeneratorFunction` constructor is the intrinsic object %Function%.
+
The value of the [[Extensible]] internal slot of the GeneratorFunction constructor is *true*.
+
The value of the `name` property of the GeneratorFunction is `"GeneratorFunction"`.
+
The `GeneratorFunction` constructor has the following properties:
+
+
+
+
GeneratorFunction.length
+
This is a data property with a value of 1. This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
GeneratorFunction.prototype
+
The initial value of `GeneratorFunction.prototype` is the intrinsic object %Generator%.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
+
Properties of the GeneratorFunction Prototype Object
+
The GeneratorFunction prototype object is an ordinary object. It is not a function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed in or . In addition to being the value of the prototype property of the %GeneratorFunction% intrinsic, it is the %Generator% intrinsic (see Figure 2).
+
The value of the [[Prototype]] internal slot of the GeneratorFunction prototype object is the %FunctionPrototype% intrinsic object. The initial value of the [[Extensible]] internal slot of the GeneratorFunction prototype object is *true*.
+
+
+
+
GeneratorFunction.prototype.constructor
+
The initial value of `GeneratorFunction.prototype.constructor` is the intrinsic object %GeneratorFunction%.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
GeneratorFunction.prototype.prototype
+
The value of `GeneratorFunction.prototype.prototype` is the %GeneratorPrototype% intrinsic object.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
GeneratorFunction.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"GeneratorFunction"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
GeneratorFunction Instances
+
Every GeneratorFunction instance is an ECMAScript function object and has the internal slots listed in . The value of the [[FunctionKind]] internal slot for all such instances is `"generator"`.
+
Each GeneratorFunction instance has the following own properties:
+
+
+
+
length
+
The value of the `length` property is an integer that indicates the typical number of arguments expected by the GeneratorFunction. However, the language permits the function to be invoked with some other number of arguments. The behaviour of a GeneratorFunction when invoked on a number of arguments other than the number specified by its `length` property depends on the function.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
name
+
The specification for the `name` property of Function instances given in also applies to GeneratorFunction instances.
+
+
+
+
+
prototype
+
Whenever a GeneratorFunction instance is created another ordinary object is also created and is the initial value of the generator function's `prototype` property. The value of the prototype property is used to initialize the [[Prototype]] internal slot of a newly created Generator object when the generator function object is invoked using [[Call]].
+
This property has the attributes { [[Writable]]: *true*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
Unlike function instances, the object that is the value of the a GeneratorFunction's `prototype` property does not have a `constructor` property whose value is the GeneratorFunction instance.
+
+
+
+
+
+
+
+
Generator Objects
+
A Generator object is an instance of a generator function and conforms to both the Iterator and Iterable interfaces.
+
Generator instances directly inherit properties from the object that is the value of the `prototype` property of the Generator function that created the instance. Generator instances indirectly inherit properties from the Generator Prototype intrinsic, %GeneratorPrototype%.
+
+
+
+
Properties of Generator Prototype
+
The Generator prototype object is the %GeneratorPrototype% intrinsic. It is also the initial value of the `prototype` property of the %Generator% intrinsic (the GeneratorFunction.prototype).
+
The Generator prototype is an ordinary object. It is not a Generator instance and does not have a [[GeneratorState]] internal slot.
+
The value of the [[Prototype]] internal slot of the Generator prototype object is the intrinsic object %IteratorPrototype% (). The initial value of the [[Extensible]] internal slot of the Generator prototype object is *true*.
+
All Generator instances indirectly inherit properties of the Generator prototype object.
+
+
+
+
Generator.prototype.constructor
+
The initial value of `Generator.prototype.constructor` is the intrinsic object %Generator%.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
Generator.prototype.next ( _value_ )
+
The `next` method performs the following steps:
+
+ 1. Let _g_ be the *this* value.
+ 1. Return GeneratorResume(_g_, _value_).
+
+
+
+
+
+
Generator.prototype.return ( _value_ )
+
The `return` method performs the following steps:
+
+ 1. Let _g_ be the *this* value.
+ 1. Let _C_ be Completion{[[type]]: ~return~, [[value]]: _value_, [[target]]: ~empty~}.
+ 1. Return GeneratorResumeAbrupt(_g_, _C_).
+
+
+
+
+
+
Generator.prototype.throw ( _exception_ )
+
The `throw` method performs the following steps:
+
+ 1. Let _g_ be the *this* value.
+ 1. Let _C_ be Completion{[[type]]: ~throw~, [[value]]: _exception_, [[target]]: ~empty~}.
+ 1. Return GeneratorResumeAbrupt(_g_, _C_).
+
+
+
+
+
+
Generator.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Generator"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Generator Instances
+
Generator instances are initially created with the internal slots described in .
+
+
+
+
+
+ Internal Slot
+
+
+ Description
+
+
+
+
+ [[GeneratorState]]
+
+
+ The current execution state of the generator. The possible values are: *undefined*, `"suspendedStart"`, `"suspendedYield"`, `"executing"`, and `"completed"`.
+
+
+
+
+ [[GeneratorContext]]
+
+
+ The execution context that is used when executing the code of this generator.
+
+
+
+
+
+
+
+
+
+
Generator Abstract Operations
+
+
+
+
GeneratorStart (_generator_, _generatorBody_)
+
The abstract operation GeneratorStart with arguments _generator_ and _generatorBody_ performs the following steps:
+
+ 1. Assert: The value of _generator_'s [[GeneratorState]] internal slot is *undefined*.
+ 1. Let _genContext_ be the running execution context.
+ 1. Set the Generator component of _genContext_ to _generator_.
+ 1. Set the code evaluation state of _genContext_ such that when evaluation is resumed for that execution context the following steps will be performed:
+ 1. Let _result_ be the result of evaluating _generatorBody_.
+ 1. Assert: If we return here, the generator either threw an exception or performed either an implicit or explicit return.
+ 1. Remove _genContext_ from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
+ 1. Set _generator_'s [[GeneratorState]] internal slot to `"completed"`.
+ 1. Once a generator enters the `"completed"` state it never leaves it and its associated execution context is never resumed. Any execution state associated with _generator_ can be discarded at this point.
+ 1. If _result_ is a normal completion, let _resultValue_ be *undefined*.
+ 1. Else,
+ 1. If _result_.[[type]] is ~return~, let _resultValue_ be _result_.[[value]].
+ 1. Else, return Completion(_result_).
+ 1. Return CreateIterResultObject(_resultValue_, *true*).
+ 1. Set _generator_'s [[GeneratorContext]] internal slot to _genContext_.
+ 1. Set _generator_'s [[GeneratorState]] internal slot to `"suspendedStart"`.
+ 1. Return NormalCompletion(*undefined*).
+
+
+
+
+
+
GeneratorValidate ( _generator_ )
+
The abstract operation GeneratorValidate with argument _generator_ performs the following steps:
+
+ 1. If Type(_generator_) is not Object, throw a *TypeError* exception.
+ 1. If _generator_ does not have a [[GeneratorState]] internal slot, throw a *TypeError* exception.
+ 1. Assert: _generator_ also has a [[GeneratorContext]] internal slot.
+ 1. Let _state_ be the value of _generator_'s [[GeneratorState]] internal slot.
+ 1. If _state_ is `"executing"`, throw a *TypeError* exception.
+ 1. Return _state_.
+
+
+
+
+
+
GeneratorResume ( _generator_, _value_ )
+
The abstract operation GeneratorResume with arguments _generator_ and _value_ performs the following steps:
+
+ 1. Let _state_ be ? GeneratorValidate(_generator_).
+ 1. If _state_ is `"completed"`, return CreateIterResultObject(*undefined*, *true*).
+ 1. Assert: _state_ is either `"suspendedStart"` or `"suspendedYield"`.
+ 1. Let _genContext_ be the value of _generator_'s [[GeneratorContext]] internal slot.
+ 1. Let _methodContext_ be the running execution context.
+ 1. Suspend _methodContext_.
+ 1. Set _generator_'s [[GeneratorState]] internal slot to `"executing"`.
+ 1. Push _genContext_ onto the execution context stack; _genContext_ is now the running execution context.
+ 1. Resume the suspended evaluation of _genContext_ using NormalCompletion(_value_) as the result of the operation that suspended it. Let _result_ be the value returned by the resumed computation.
+ 1. Assert: When we return here, _genContext_ has already been removed from the execution context stack and _methodContext_ is the currently running execution context.
+ 1. Return Completion(_result_).
+
+
+
+
+
+
The abstract operation GeneratorResumeAbrupt with arguments _generator_ and _abruptCompletion_ performs the following steps:
+
+ 1. Let _state_ be ? GeneratorValidate(_generator_).
+ 1. If _state_ is `"suspendedStart"`, then
+ 1. Set _generator_'s [[GeneratorState]] internal slot to `"completed"`.
+ 1. Once a generator enters the `"completed"` state it never leaves it and its associated execution context is never resumed. Any execution state associated with _generator_ can be discarded at this point.
+ 1. Let _state_ be `"completed"`.
+ 1. If _state_ is `"completed"`, then
+ 1. If _abruptCompletion_.[[type]] is ~return~, then
+ 1. Return CreateIterResultObject(_abruptCompletion_.[[value]], *true*).
+ 1. Return Completion(_abruptCompletion_).
+ 1. Assert: _state_ is `"suspendedYield"`.
+ 1. Let _genContext_ be the value of _generator_'s [[GeneratorContext]] internal slot.
+ 1. Let _methodContext_ be the running execution context.
+ 1. Suspend _methodContext_.
+ 1. Set _generator_'s [[GeneratorState]] internal slot to `"executing"`.
+ 1. Push _genContext_ onto the execution context stack; _genContext_ is now the running execution context.
+ 1. Resume the suspended evaluation of _genContext_ using _abruptCompletion_ as the result of the operation that suspended it. Let _result_ be the completion record returned by the resumed computation.
+ 1. Assert: When we return here, _genContext_ has already been removed from the execution context stack and _methodContext_ is the currently running execution context.
+ 1. Return Completion(_result_).
+
+
+
+
+
+
GeneratorYield ( _iterNextObj_ )
+
The abstract operation GeneratorYield with argument _iterNextObj_ performs the following steps:
+
+ 1. Assert: _iterNextObj_ is an Object that implements the IteratorResult interface.
+ 1. Let _genContext_ be the running execution context.
+ 1. Assert: _genContext_ is the execution context of a generator.
+ 1. Let _generator_ be the value of the Generator component of _genContext_.
+ 1. Set the value of _generator_'s [[GeneratorState]] internal slot to `"suspendedYield"`.
+ 1. Remove _genContext_ from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
+ 1. Set the code evaluation state of _genContext_ such that when evaluation is resumed with a Completion _resumptionValue_ the following steps will be performed:
+ 1. Return _resumptionValue_.
+ 1. NOTE: This returns to the evaluation of the |YieldExpression| production that originally called this abstract operation.
+ 1. Return NormalCompletion(_iterNextObj_).
+ 1. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of _genContext_.
+
+
+
+
+
+
+
+
Promise Objects
+
A Promise is an object that is used as a placeholder for the eventual results of a deferred (and possibly asynchronous) computation.
+
Any Promise object is in one of three mutually exclusive states: fulfilled, rejected, and pending:
+
+
+ A promise `p` is fulfilled if `p.then(f, r)` will immediately enqueue a Job to call the function `f`.
+
+
+ A promise `p` is rejected if `p.then(f, r)` will immediately enqueue a Job to call the function `r`.
+
+
+ A promise is pending if it is neither fulfilled nor rejected.
+
+
+
A promise is said to be settled if it is not pending, i.e. if it is either fulfilled or rejected.
+
A promise is resolved if it is settled or if it has been “locked in” to match the state of another promise. Attempting to resolve or reject a resolved promise has no effect. A promise is unresolved if it is not resolved. An unresolved promise is always in the pending state. A resolved promise may be pending, fulfilled or rejected.
+
+
+
+
Promise Abstract Operations
+
+
+
+
PromiseCapability Records
+
A PromiseCapability is a Record value used to encapsulate a promise object along with the functions that are capable of resolving or rejecting that promise object. PromiseCapability records are produced by the NewPromiseCapability abstract operation.
+
PromiseCapability Records have the fields listed in .
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[Promise]]
+
+
+ An object
+
+
+ An object that is usable as a promise.
+
+
+
+
+ [[Resolve]]
+
+
+ A function object
+
+
+ The function that is used to resolve the given promise object.
+
+
+
+
+ [[Reject]]
+
+
+ A function object
+
+
+ The function that is used to reject the given promise object.
+
+
+
+
+
+
+
+
+
IfAbruptRejectPromise ( _value_, _capability_ )
+
IfAbruptRejectPromise is a short hand for a sequence of algorithm steps that use a PromiseCapability record. An algorithm step of the form:
+
+ 1. If _value_ is an abrupt completion, then
+ 1. Let _rejectResult_ be ? Call(_capability_.[[Reject]], *undefined*, « _value_.[[value]] »).
+ 1. Return _capability_.[[Promise]].
+ 1. Else if _value_ is a Completion Record, let _value_ be _value_.[[value]].
+
+
+
+
+
+
+
PromiseReaction Records
+
The PromiseReaction is a Record value used to store information about how a promise should react when it becomes resolved or rejected with a given value. PromiseReaction records are created by the PerformPromiseThen abstract operation, and are used by a PromiseReactionJob.
+
PromiseReaction records have the fields listed in .
+
+
+
+
+
+ Field Name
+
+
+ Value
+
+
+ Meaning
+
+
+
+
+ [[Capabilities]]
+
+
+ A PromiseCapability record
+
+
+ The capabilities of the promise for which this record provides a reaction handler.
+
+
+
+
+ [[Handler]]
+
+
+ A function object or a String
+
+
+ The function that should be applied to the incoming value, and whose return value will govern what happens to the derived promise. If [[Handler]] is `"Identity"` it is equivalent to a function that simply returns its first argument. If [[Handler]] is `"Thrower"` it is equivalent to a function that throws its first argument as an exception.
+
+
+
+
+
+
+
+
+
+
CreateResolvingFunctions ( _promise_ )
+
When CreateResolvingFunctions is performed with argument _promise_, the following steps are taken:
+
+ 1. Let _alreadyResolved_ be a new Record { [[value]]: *false* }.
+ 1. Let _resolve_ be a new built-in function object as defined in Promise Resolve Functions ().
+ 1. Set the [[Promise]] internal slot of _resolve_ to _promise_.
+ 1. Set the [[AlreadyResolved]] internal slot of _resolve_ to _alreadyResolved_.
+ 1. Let _reject_ be a new built-in function object as defined in Promise Reject Functions ().
+ 1. Set the [[Promise]] internal slot of _reject_ to _promise_.
+ 1. Set the [[AlreadyResolved]] internal slot of _reject_ to _alreadyResolved_.
+ 1. Return a new Record { [[Resolve]]: _resolve_, [[Reject]]: _reject_ }.
+
+
+
+
+
Promise Reject Functions
+
A promise reject function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.
+
When a promise reject function _F_ is called with argument _reason_, the following steps are taken:
+
+ 1. Assert: _F_ has a [[Promise]] internal slot whose value is an Object.
+ 1. Let _promise_ be the value of _F_'s [[Promise]] internal slot.
+ 1. Let _alreadyResolved_ be the value of _F_'s [[AlreadyResolved]] internal slot.
+ 1. If _alreadyResolved_.[[value]] is *true*, return *undefined*.
+ 1. Set _alreadyResolved_.[[value]] to *true*.
+ 1. Return RejectPromise(_promise_, _reason_).
+
+
The `length` property of a promise reject function is 1.
+
+
+
+
+
Promise Resolve Functions
+
A promise resolve function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.
+
When a promise resolve function _F_ is called with argument _resolution_, the following steps are taken:
+
+ 1. Assert: _F_ has a [[Promise]] internal slot whose value is an Object.
+ 1. Let _promise_ be the value of _F_'s [[Promise]] internal slot.
+ 1. Let _alreadyResolved_ be the value of _F_'s [[AlreadyResolved]] internal slot.
+ 1. If _alreadyResolved_.[[value]] is *true*, return *undefined*.
+ 1. Set _alreadyResolved_.[[value]] to *true*.
+ 1. If SameValue(_resolution_, _promise_) is *true*, then
+ 1. Let _selfResolutionError_ be a newly created *TypeError* object.
+ 1. Return RejectPromise(_promise_, _selfResolutionError_).
+ 1. If Type(_resolution_) is not Object, then
+ 1. Return FulfillPromise(_promise_, _resolution_).
+ 1. Let _then_ be Get(_resolution_, `"then"`).
+ 1. If _then_ is an abrupt completion, then
+ 1. Return RejectPromise(_promise_, _then_.[[value]]).
+ 1. Let _thenAction_ be _then_.[[value]].
+ 1. If IsCallable(_thenAction_) is *false*, then
+ 1. Return FulfillPromise(_promise_, _resolution_).
+ 1. Perform EnqueueJob(`"PromiseJobs"`, PromiseResolveThenableJob, « _promise_, _resolution_, _thenAction_ »).
+ 1. Return *undefined*.
+
+
The `length` property of a promise resolve function is 1.
+
+
+
+
+
+
FulfillPromise ( _promise_, _value_)
+
When the FulfillPromise abstract operation is called with arguments _promise_ and _value_ the following steps are taken:
+
+ 1. Assert: the value of _promise_'s [[PromiseState]] internal slot is `"pending"`.
+ 1. Let _reactions_ be the value of _promise_'s [[PromiseFulfillReactions]] internal slot.
+ 1. Set the value of _promise_'s [[PromiseResult]] internal slot to _value_.
+ 1. Set the value of _promise_'s [[PromiseFulfillReactions]] internal slot to *undefined*.
+ 1. Set the value of _promise_'s [[PromiseRejectReactions]] internal slot to *undefined*.
+ 1. Set the value of _promise_'s [[PromiseState]] internal slot to `"fulfilled"`.
+ 1. Return TriggerPromiseReactions(_reactions_, _value_).
+
+
+
+
+
+
NewPromiseCapability ( _C_ )
+
The abstract operation NewPromiseCapability takes a constructor function, and attempts to use that constructor function in the fashion of the built-in `Promise` constructor to create a Promise object and extract its resolve and reject functions. The promise plus the resolve and reject functions are used to initialize a new PromiseCapability record which is returned as the value of this abstract operation.
+
+ 1. If IsConstructor(_C_) is *false*, throw a *TypeError* exception.
+ 1. NOTE _C_ is assumed to be a constructor function that supports the parameter conventions of the `Promise` constructor (see ).
+ 1. Let _promiseCapability_ be a new PromiseCapability { [[Promise]]: *undefined*, [[Resolve]]: *undefined*, [[Reject]]: *undefined* }.
+ 1. Let _executor_ be a new built-in function object as defined in GetCapabilitiesExecutor Functions ().
+ 1. Set the [[Capability]] internal slot of _executor_ to _promiseCapability_.
+ 1. Let _promise_ be ? Construct(_C_, « _executor_ »).
+ 1. If IsCallable(_promiseCapability_.[[Resolve]]) is *false*, throw a *TypeError* exception.
+ 1. If IsCallable(_promiseCapability_.[[Reject]]) is *false*, throw a *TypeError* exception.
+ 1. Set _promiseCapability_.[[Promise]] to _promise_.
+ 1. Return _promiseCapability_.
+
+
+
This abstract operation supports Promise subclassing, as it is generic on any constructor that calls a passed executor function argument in the same way as the Promise constructor. It is used to generalize static methods of the Promise constructor to any subclass.
+
+
+
+
+
GetCapabilitiesExecutor Functions
+
A GetCapabilitiesExecutor function is an anonymous built-in function that has a [[Capability]] internal slot.
+
When a GetCapabilitiesExecutor function _F_ is called with arguments _resolve_ and _reject_ the following steps are taken:
+
+ 1. Assert: _F_ has a [[Capability]] internal slot whose value is a PromiseCapability Record.
+ 1. Let _promiseCapability_ be the value of _F_'s [[Capability]] internal slot.
+ 1. If _promiseCapability_.[[Resolve]] is not *undefined*, throw a *TypeError* exception.
+ 1. If _promiseCapability_.[[Reject]] is not *undefined*, throw a *TypeError* exception.
+ 1. Set _promiseCapability_.[[Resolve]] to _resolve_.
+ 1. Set _promiseCapability_.[[Reject]] to _reject_.
+ 1. Return *undefined*.
+
+
The `length` property of a GetCapabilitiesExecutor function is 2.
+
+
+
+
+
+
IsPromise ( _x_ )
+
The abstract operation IsPromise checks for the promise brand on an object.
+
+ 1. If Type(_x_) is not Object, return *false*.
+ 1. If _x_ does not have a [[PromiseState]] internal slot, return *false*.
+ 1. Return *true*.
+
+
+
+
+
+
RejectPromise ( _promise_, _reason_ )
+
When the RejectPromise abstract operation is called with arguments _promise_ and _reason_ the following steps are taken:
+
+ 1. Assert: the value of _promise_'s [[PromiseState]] internal slot is `"pending"`.
+ 1. Let _reactions_ be the value of _promise_'s [[PromiseRejectReactions]] internal slot.
+ 1. Set the value of _promise_'s [[PromiseResult]] internal slot to _reason_.
+ 1. Set the value of _promise_'s [[PromiseFulfillReactions]] internal slot to *undefined*.
+ 1. Set the value of _promise_'s [[PromiseRejectReactions]] internal slot to *undefined*.
+ 1. Set the value of _promise_'s [[PromiseState]] internal slot to `"rejected"`.
+ 1. If the value of _promise_'s [[PromiseIsHandled]] internal slot is *false*, perform HostPromiseRejectionTracker(_promise_, `"reject"`).
+ 1. Return TriggerPromiseReactions(_reactions_, _reason_).
+
+
+
+
+
+
The abstract operation TriggerPromiseReactions takes a collection of PromiseReactionRecords and enqueues a new Job for each record. Each such Job processes the [[Handler]] of the PromiseReactionRecord, and if the [[Handler]] is a function calls it passing the given argument.
+
+ 1. Repeat for each _reaction_ in _reactions_, in original insertion order
+ 1. Perform EnqueueJob(`"PromiseJobs"`, PromiseReactionJob, « _reaction_, _argument_ »).
+ 1. Return *undefined*.
+
+
+
+
+
HostPromiseRejectionTracker is an implementation-defined abstract operation that allows host environments to track promise rejections.
+
+
An implementation of HostPromiseRejectionTracker must complete normally in all cases. The default implementation of HostPromiseRejectionTracker is to do nothing.
+
+
+
HostPromiseRejectionTracker is called in two scenarios:
+
+
+
When a promise is rejected without any handlers, it is called with its _operation_ argument set to `"reject"`.
+
When a handler is added to a rejected promise for the first time, it is called with its _operation_ argument set to `"handle"`.
+
+
+
A typical implementation of HostPromiseRejectionTracker might try to notify developers of unhandled rejections, while also being careful to notify them if such previous notifications are later invalidated by new handlers being attached.
+
+
+
+
If _operation_ is `"handle"`, an implementation should not hold a reference to promise in a way that would interfere with garbage collection. An implementation may hold a reference to promise if operation is `"reject"`, since it is expected that rejections will be rare and not on hot code paths.
+
+
+
+
+
+
+
Promise Jobs
+
+
+
+
PromiseReactionJob ( _reaction_, _argument_ )
+
The job PromiseReactionJob with parameters _reaction_ and _argument_ applies the appropriate handler to the incoming value, and uses the handler's return value to resolve or reject the derived promise associated with that handler.
+
+ 1. Assert: _reaction_ is a PromiseReaction Record.
+ 1. Let _promiseCapability_ be _reaction_.[[Capabilities]].
+ 1. Let _handler_ be _reaction_.[[Handler]].
+ 1. If _handler_ is `"Identity"`, let _handlerResult_ be NormalCompletion(_argument_).
+ 1. Else if _handler_ is `"Thrower"`, let _handlerResult_ be Completion{[[type]]: ~throw~, [[value]]: _argument_, [[target]]: ~empty~}.
+ 1. Else, let _handlerResult_ be Call(_handler_, *undefined*, « _argument_ »).
+ 1. If _handlerResult_ is an abrupt completion, then
+ 1. Let _status_ be Call(_promiseCapability_.[[Reject]], *undefined*, « _handlerResult_.[[value]] »).
+ 1. NextJob Completion(_status_).
+ 1. Let _status_ be Call(_promiseCapability_.[[Resolve]], *undefined*, « _handlerResult_.[[value]] »).
+ 1. NextJob Completion(_status_).
+
+
+
+
+
+
The job PromiseResolveThenableJob with parameters _promiseToResolve_, _thenable_, and _then_ performs the following steps:
+
+ 1. Let _resolvingFunctions_ be CreateResolvingFunctions(_promiseToResolve_).
+ 1. Let _thenCallResult_ be Call(_then_, _thenable_, « _resolvingFunctions_.[[Resolve]], _resolvingFunctions_.[[Reject]] »).
+ 1. If _thenCallResult_ is an abrupt completion, then
+ 1. Let _status_ be Call(_resolvingFunctions_.[[Reject]], *undefined*, « _thenCallResult_.[[value]] »).
+ 1. NextJob Completion(_status_).
+ 1. NextJob Completion(_thenCallResult_).
+
+
+
This Job uses the supplied thenable and its `then` method to resolve the given promise. This process must take place as a Job to ensure that the evaluation of the `then` method occurs after evaluation of any surrounding code has completed.
+
+
+
+
+
+
+
The Promise Constructor
+
The Promise constructor is the %Promise% intrinsic object and the initial value of the `Promise` property of the global object. When called as a constructor it creates and initializes a new Promise object. `Promise` is not intended to be called as a function and will throw an exception when called in that manner.
+
The `Promise` constructor is designed to be subclassable. It may be used as the value in an `extends` clause of a class definition. Subclass constructors that intend to inherit the specified `Promise` behaviour must include a `super` call to the `Promise` constructor to create and initialize the subclass instance with the internal state necessary to support the `Promise` and `Promise.prototype` built-in methods.
+
+
+
+
Promise ( _executor_ )
+
When the `Promise` function is called with argument _executor_ the following steps are taken:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. If IsCallable(_executor_) is *false*, throw a *TypeError* exception.
+ 1. Let _promise_ be ? OrdinaryCreateFromConstructor(NewTarget, `"%PromisePrototype%"`, « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] » ).
+ 1. Set _promise_'s [[PromiseState]] internal slot to `"pending"`.
+ 1. Set _promise_'s [[PromiseFulfillReactions]] internal slot to a new empty List.
+ 1. Set _promise_'s [[PromiseRejectReactions]] internal slot to a new empty List.
+ 1. Set _promise_'s [[PromiseIsHandled]] internal slot to *false*.
+ 1. Let _resolvingFunctions_ be CreateResolvingFunctions(_promise_).
+ 1. Let _completion_ be Call(_executor_, *undefined*, « _resolvingFunctions_.[[Resolve]], _resolvingFunctions_.[[Reject]] »).
+ 1. If _completion_ is an abrupt completion, then
+ 1. Let _status_ be ? Call(_resolvingFunctions_.[[Reject]], *undefined*, « _completion_.[[value]] »).
+ 1. Return _promise_.
+
+
+
The _executor_ argument must be a function object. It is called for initiating and reporting completion of the possibly deferred action represented by this Promise object. The executor is called with two arguments: _resolve_ and _reject_. These are functions that may be used by the _executor_ function to report eventual completion or failure of the deferred computation. Returning from the executor function does not mean that the deferred action has been completed but only that the request to eventually perform the deferred action has been accepted.
+
The _resolve_ function that is passed to an _executor_ function accepts a single argument. The _executor_ code may eventually call the _resolve_ function to indicate that it wishes to resolve the associated Promise object. The argument passed to the _resolve_ function represents the eventual value of the deferred action and can be either the actual fulfillment value or another Promise object which will provide the value if it is fulfilled.
+
The _reject_ function that is passed to an _executor_ function accepts a single argument. The _executor_ code may eventually call the _reject_ function to indicate that the associated Promise is rejected and will never be fulfilled. The argument passed to the _reject_ function is used as the rejection value of the promise. Typically it will be an `Error` object.
+
The resolve and reject functions passed to an _executor_ function by the Promise constructor have the capability to actually resolve and reject the associated promise. Subclasses may have different constructor behaviour that passes in customized values for resolve and reject.
+
+
+
+
+
+
+
Properties of the Promise Constructor
+
The value of the [[Prototype]] internal slot of the `Promise` constructor is the intrinsic object %FunctionPrototype% ().
+
Besides the `length` property (whose value is 1), the Promise constructor has the following properties:
+
+
+
+
Promise.all ( _iterable_ )
+
The `all` function returns a new promise which is fulfilled with an array of fulfillment values for the passed promises, or rejects with the reason of the first passed promise that rejects. It resolves all elements of the passed iterable to promises as it runs this algorithm.
+
+ 1. Let _C_ be the *this* value.
+ 1. If Type(_C_) is not Object, throw a *TypeError* exception.
+ 1. Let _promiseCapability_ be ? NewPromiseCapability(_C_).
+ 1. Let _iterator_ be GetIterator(_iterable_).
+ 1. IfAbruptRejectPromise(_iterator_, _promiseCapability_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. Let _result_ be PerformPromiseAll(_iteratorRecord_, _C_, _promiseCapability_).
+ 1. If _result_ is an abrupt completion, then
+ 1. If _iteratorRecord_.[[done]] is *false*, let _result_ be IteratorClose(_iterator_, _result_).
+ 1. IfAbruptRejectPromise(_result_, _promiseCapability_).
+ 1. Return Completion(_result_).
+
+
+
The `all` function requires its *this* value to be a constructor function that supports the parameter conventions of the `Promise` constructor.
When the PerformPromiseAll abstract operation is called with arguments _iteratorRecord_, _constructor_, and _resultCapability_ the following steps are taken:
+
+ 1. Assert: _constructor_ is a constructor function.
+ 1. Assert: _resultCapability_ is a PromiseCapability record.
+ 1. Let _values_ be a new empty List.
+ 1. Let _remainingElementsCount_ be a new Record { [[value]]: 1 }.
+ 1. Let _index_ be 0.
+ 1. Repeat
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, then
+ 1. Set _iteratorRecord_.[[done]] to *true*.
+ 1. Set _remainingElementsCount_.[[value]] to _remainingElementsCount_.[[value]] - 1.
+ 1. If _remainingElementsCount_.[[value]] is 0, then
+ 1. Let _valuesArray_ be CreateArrayFromList(_values_).
+ 1. Let _resolveResult_ be ? Call(_resultCapability_.[[Resolve]], *undefined*, « _valuesArray_ »).
+ 1. Return _resultCapability_.[[Promise]].
+ 1. Let _nextValue_ be IteratorValue(_next_).
+ 1. If _nextValue_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_nextValue_).
+ 1. Append *undefined* to _values_.
+ 1. Let _nextPromise_ be ? Invoke(_constructor_, `"resolve"`, « _nextValue_ »).
+ 1. Let _resolveElement_ be a new built-in function object as defined in Promise.all Resolve Element Functions.
+ 1. Set the [[AlreadyCalled]] internal slot of _resolveElement_ to a new Record {[[value]]: *false* }.
+ 1. Set the [[Index]] internal slot of _resolveElement_ to _index_.
+ 1. Set the [[Values]] internal slot of _resolveElement_ to _values_.
+ 1. Set the [[Capabilities]] internal slot of _resolveElement_ to _resultCapability_.
+ 1. Set the [[RemainingElements]] internal slot of _resolveElement_ to _remainingElementsCount_.
+ 1. Set _remainingElementsCount_.[[value]] to _remainingElementsCount_.[[value]] + 1.
+ 1. Let _result_ be ? Invoke(_nextPromise_, `"then"`, « _resolveElement_, _resultCapability_.[[Reject]] »).
+ 1. Set _index_ to _index_ + 1.
+
+
+
+
+
+
Promise.all Resolve Element Functions
+
A Promise.all resolve element function is an anonymous built-in function that is used to resolve a specific Promise.all element. Each Promise.all resolve element function has [[Index]], [[Values]], [[Capabilities]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.
+
When a Promise.all resolve element function _F_ is called with argument _x_, the following steps are taken:
+
+ 1. Let _alreadyCalled_ be the value of _F_'s [[AlreadyCalled]] internal slot.
+ 1. If _alreadyCalled_.[[value]] is *true*, return *undefined*.
+ 1. Set _alreadyCalled_.[[value]] to *true*.
+ 1. Let _index_ be the value of _F_'s [[Index]] internal slot.
+ 1. Let _values_ be the value of _F_'s [[Values]] internal slot.
+ 1. Let _promiseCapability_ be the value of _F_'s [[Capabilities]] internal slot.
+ 1. Let _remainingElementsCount_ be the value of _F_'s [[RemainingElements]] internal slot.
+ 1. Set _values_[_index_] to _x_.
+ 1. Set _remainingElementsCount_.[[value]] to _remainingElementsCount_.[[value]] - 1.
+ 1. If _remainingElementsCount_.[[value]] is 0, then
+ 1. Let _valuesArray_ be CreateArrayFromList(_values_).
+ 1. Return Call(_promiseCapability_.[[Resolve]], *undefined*, « _valuesArray_ »).
+ 1. Return *undefined*.
+
+
The `length` property of a Promise.all resolve element function is 1.
+
+
+
+
+
+
Promise.prototype
+
The initial value of `Promise.prototype` is the intrinsic object %PromisePrototype% ().
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *false* }.
+
+
+
+
+
Promise.race ( _iterable_ )
+
The `race` function returns a new promise which is settled in the same way as the first passed promise to settle. It resolves all elements of the passed _iterable_ to promises as it runs this algorithm.
+
+ 1. Let _C_ be the *this* value.
+ 1. If Type(_C_) is not Object, throw a *TypeError* exception.
+ 1. Let _promiseCapability_ be ? NewPromiseCapability(_C_).
+ 1. Let _iterator_ be GetIterator(_iterable_).
+ 1. IfAbruptRejectPromise(_iterator_, _promiseCapability_).
+ 1. Let _iteratorRecord_ be Record {[[iterator]]: _iterator_, [[done]]: *false*}.
+ 1. Let _result_ be PerformPromiseRace(_iteratorRecord_, _promiseCapability_, _C_).
+ 1. If _result_ is an abrupt completion, then
+ 1. If _iteratorRecord_.[[done]] is *false*, let _result_ be IteratorClose(_iterator_,_result_).
+ 1. IfAbruptRejectPromise(_result_, _promiseCapability_).
+ 1. Return Completion(_result_).
+
+
+
If the _iterable_ argument is empty or if none of the promises in _iterable_ ever settle then the pending promise returned by this method will never be settled.
+
+
+
The `race` function expects its *this* value to be a constructor function that supports the parameter conventions of the `Promise` constructor. It also expects that its *this* value provides a `resolve` method.
When the PerformPromiseRace abstract operation is called with arguments _iteratorRecord_, _promiseCapability_, and _C_ the following steps are taken:
+
+ 1. Repeat
+ 1. Let _next_ be IteratorStep(_iteratorRecord_.[[iterator]]).
+ 1. If _next_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_next_).
+ 1. If _next_ is *false*, then
+ 1. Set _iteratorRecord_.[[done]] to *true*.
+ 1. Return _promiseCapability_.[[Promise]].
+ 1. Let _nextValue_ be IteratorValue(_next_).
+ 1. If _nextValue_ is an abrupt completion, set _iteratorRecord_.[[done]] to *true*.
+ 1. ReturnIfAbrupt(_nextValue_).
+ 1. Let _nextPromise_ be ? Invoke(_C_, `"resolve"`, « _nextValue_ »).
+ 1. Let _result_ be ? Invoke(_nextPromise_, `"then"`, « _promiseCapability_.[[Resolve]], _promiseCapability_.[[Reject]] »).
+
+
+
+
+
+
+
Promise.reject ( _r_ )
+
The `reject` function returns a new promise rejected with the passed argument.
+
+ 1. Let _C_ be the *this* value.
+ 1. If Type(_C_) is not Object, throw a *TypeError* exception.
+ 1. Let _promiseCapability_ be ? NewPromiseCapability(_C_).
+ 1. Let _rejectResult_ be ? Call(_promiseCapability_.[[Reject]], *undefined*, « _r_ »).
+ 1. Return _promiseCapability_.[[Promise]].
+
+
+
The `reject` function expects its *this* value to be a constructor function that supports the parameter conventions of the `Promise` constructor.
+
+
+
+
+
+
Promise.resolve ( _x_ )
+
The `resolve` function returns either a new promise resolved with the passed argument, or the argument itself if the argument is a promise produced by this constructor.
+
+ 1. Let _C_ be the *this* value.
+ 1. If Type(_C_) is not Object, throw a *TypeError* exception.
+ 1. If IsPromise(_x_) is *true*, then
+ 1. Let _xConstructor_ be ? Get(_x_, `"constructor"`).
+ 1. If SameValue(_xConstructor_, _C_) is *true*, return _x_.
+ 1. Let _promiseCapability_ be ? NewPromiseCapability(_C_).
+ 1. Let _resolveResult_ be ? Call(_promiseCapability_.[[Resolve]], *undefined*, « _x_ »).
+ 1. Return _promiseCapability_.[[Promise]].
+
+
+
The `resolve` function expects its *this* value to be a constructor function that supports the parameter conventions of the `Promise` constructor.
+
+
+
+
+
+
get Promise [ @@species ]
+
`Promise[@@species]` is an accessor property whose set accessor function is *undefined*. Its get accessor function performs the following steps:
+
+ 1. Return the *this* value.
+
+
The value of the `name` property of this function is `"get [Symbol.species]"`.
+
+
Promise prototype methods normally use their `this` object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.
+
+
+
+
+
+
+
Properties of the Promise Prototype Object
+
The Promise prototype object is the intrinsic object %PromisePrototype%. The value of the [[Prototype]] internal slot of the Promise prototype object is the intrinsic object %ObjectPrototype% (). The Promise prototype object is an ordinary object. It does not have a [[PromiseState]] internal slot or any of the other internal slots of Promise instances.
+
+
+
+
Promise.prototype.catch ( _onRejected_ )
+
When the `catch` method is called with argument _onRejected_ the following steps are taken:
+
+ 1. Let _promise_ be the *this* value.
+ 1. Return Invoke(_promise_, `"then"`, « *undefined*, _onRejected_ »).
+
+
+
+
+
+
Promise.prototype.constructor
+
The initial value of `Promise.prototype.constructor` is the intrinsic object %Promise%.
When the `then` method is called with arguments _onFulfilled_ and _onRejected_ the following steps are taken:
+
+ 1. Let _promise_ be the *this* value.
+ 1. If IsPromise(_promise_) is *false*, throw a *TypeError* exception.
+ 1. Let _C_ be ? SpeciesConstructor(_promise_, %Promise%).
+ 1. Let _resultCapability_ be ? NewPromiseCapability(_C_).
+ 1. Return PerformPromiseThen(_promise_, _onFulfilled_, _onRejected_, _resultCapability_).
+
+
+
+
+
The abstract operation PerformPromiseThen performs the “then” operation on _promise_ using _onFulfilled_ and _onRejected_ as its settlement actions. The result is _resultCapability_'s promise.
+
+ 1. Assert: IsPromise(_promise_) is *true*.
+ 1. Assert: _resultCapability_ is a PromiseCapability record.
+ 1. If IsCallable(_onFulfilled_) is *false*, then
+ 1. Let _onFulfilled_ be `"Identity"`.
+ 1. If IsCallable(_onRejected_) is *false*, then
+ 1. Let _onRejected_ be `"Thrower"`.
+ 1. Let _fulfillReaction_ be the PromiseReaction { [[Capabilities]]: _resultCapability_, [[Handler]]: _onFulfilled_ }.
+ 1. Let _rejectReaction_ be the PromiseReaction { [[Capabilities]]: _resultCapability_, [[Handler]]: _onRejected_}.
+ 1. If the value of _promise_'s [[PromiseState]] internal slot is `"pending"`, then
+ 1. Append _fulfillReaction_ as the last element of the List that is the value of _promise_'s [[PromiseFulfillReactions]] internal slot.
+ 1. Append _rejectReaction_ as the last element of the List that is the value of _promise_'s [[PromiseRejectReactions]] internal slot.
+ 1. Else if the value of _promise_'s [[PromiseState]] internal slot is `"fulfilled"`, then
+ 1. Let _value_ be the value of _promise_'s [[PromiseResult]] internal slot.
+ 1. Perform EnqueueJob(`"PromiseJobs"`, PromiseReactionJob, « _fulfillReaction_, _value_ »).
+ 1. Else,
+ 1. Assert: The value of _promise_'s [[PromiseState]] internal slot is `"rejected"`.
+ 1. Let _reason_ be the value of _promise_'s [[PromiseResult]] internal slot.
+ 1. If the value of _promise_'s [[PromiseIsHandled]] internal slot is *false*, perform HostPromiseRejectionTracker(_promise_, `"handle"`).
+ 1. Perform EnqueueJob(`"PromiseJobs"`, PromiseReactionJob, « _rejectReaction_, _reason_ »).
+ 1. Set _promise_'s [[PromiseIsHandled]] internal slot to *true*.
+ 1. Return _resultCapability_.[[Promise]].
+
+
+
+
+
+
+
Promise.prototype [ @@toStringTag ]
+
The initial value of the @@toStringTag property is the String value `"Promise"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
+
Properties of Promise Instances
+
Promise instances are ordinary objects that inherit properties from the Promise prototype object (the intrinsic, %PromisePrototype%). Promise instances are initially created with the internal slots described in .
+
+
+
+
+
+ Internal Slot
+
+
+ Description
+
+
+
+
+ [[PromiseState]]
+
+
+ A String value that governs how a promise will react to incoming calls to its `then` method. The possible values are: `"pending"`, `"fulfilled"`, and `"rejected"`.
+
+
+
+
+ [[PromiseResult]]
+
+
+ The value with which the promise has been fulfilled or rejected, if any. Only meaningful if [[PromiseState]] is not `"pending"`.
+
+
+
+
+ [[PromiseFulfillReactions]]
+
+
+ A List of PromiseReaction records to be processed when/if the promise transitions from the `"pending"` state to the `"fulfilled"` state.
+
+
+
+
+ [[PromiseRejectReactions]]
+
+
+ A List of PromiseReaction records to be processed when/if the promise transitions from the `"pending"` state to the `"rejected"` state.
+
+
+
+
+ [[PromiseIsHandled]]
+
+
+ A boolean indicating whether the promise has ever had a fulfillment or rejection handler; used in unhandled rejection tracking.
+
+
+
+
+
+
+
+
+
+
+
+
Reflection
+
+
+
+
The Reflect Object
+
The Reflect object is the %Reflect% intrinsic object and the initial value of the `Reflect` property of the global object.The Reflect object is an ordinary object.
+
The value of the [[Prototype]] internal slot of the Reflect object is the intrinsic object %ObjectPrototype% ().
+
The Reflect object is not a function object. It does not have a [[Construct]] internal method; it is not possible to use the Reflect object as a constructor with the `new` operator. The Reflect object also does not have a [[Call]] internal method; it is not possible to invoke the Reflect object as a function.
When the `construct` function is called with arguments _target_, _argumentsList_, and _newTarget_ the following steps are taken:
+
+ 1. If IsConstructor(_target_) is *false*, throw a *TypeError* exception.
+ 1. If _newTarget_ is not present, let _newTarget_ be _target_.
+ 1. Else, if IsConstructor(_newTarget_) is *false*, throw a *TypeError* exception.
+ 1. Let _args_ be ? CreateListFromArrayLike(_argumentsList_).
+ 1. Return Construct(_target_, _args_, _newTarget_).
+
+
The `length` property of the `construct` function is 2.
When the `defineProperty` function is called with arguments _target_, _propertyKey_, and _attributes_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_propertyKey_).
+ 1. Let _desc_ be ? ToPropertyDescriptor(_attributes_).
+ 1. Return _target_.[[DefineOwnProperty]](_key_, _desc_).
+
+
+
+
+
+
When the `deleteProperty` function is called with arguments _target_ and _propertyKey_, the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_propertyKey_).
+ 1. Return _target_.[[Delete]](_key_).
+
+
+
+
+
+
Reflect.enumerate ( _target_ )
+
When the `enumerate` function is called with argument _target_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Return _target_.[[Enumerate]]().
+
+
+
+
+
+
When the `get` function is called with arguments _target_, _propertyKey_, and _receiver_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_propertyKey_).
+ 1. If _receiver_ is not present, then
+ 1. Let _receiver_ be _target_.
+ 1. Return _target_.[[Get]](_key_, _receiver_).
+
+
When the `getOwnPropertyDescriptor` function is called with arguments _target_ and _propertyKey_, the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_propertyKey_).
+ 1. Let _desc_ be ? _target_.[[GetOwnProperty]](_key_).
+ 1. Return FromPropertyDescriptor(_desc_).
+
+
+
+
+
+
Reflect.getPrototypeOf ( _target_ )
+
When the `getPrototypeOf` function is called with argument _target_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Return _target_.[[GetPrototypeOf]]().
+
+
+
+
+
+
Reflect.has ( _target_, _propertyKey_ )
+
When the `has` function is called with arguments _target_ and _propertyKey_, the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_propertyKey_).
+ 1. Return _target_.[[HasProperty]](_key_).
+
+
+
+
+
+
Reflect.isExtensible (_target_)
+
When the `isExtensible` function is called with argument _target_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Return _target_.[[IsExtensible]]().
+
+
+
+
+
+
Reflect.ownKeys ( _target_ )
+
When the `ownKeys` function is called with argument _target_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _keys_ be ? _target_.[[OwnPropertyKeys]]().
+ 1. Return CreateArrayFromList(_keys_).
+
+
+
+
+
+
Reflect.preventExtensions ( _target_ )
+
When the `preventExtensions` function is called with argument _target_, the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Return _target_.[[PreventExtensions]]().
+
+
+
+
+
+
When the `set` function is called with arguments _target_, _V_, _propertyKey_, and _receiver_ the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. Let _key_ be ? ToPropertyKey(_propertyKey_).
+ 1. If _receiver_ is not present, then
+ 1. Let _receiver_ be _target_.
+ 1. Return _target_.[[Set]](_key_, _V_, _receiver_).
+
+
The `length` property of the `set` function is 3.
+
+
+
+
+
Reflect.setPrototypeOf ( _target_, _proto_ )
+
When the `setPrototypeOf` function is called with arguments _target_ and _proto_, the following steps are taken:
+
+ 1. If Type(_target_) is not Object, throw a *TypeError* exception.
+ 1. If Type(_proto_) is not Object and _proto_ is not *null*, throw a *TypeError* exception.
+ 1. Return _target_.[[SetPrototypeOf]](_proto_).
+
+
+
+
+
+
+
Proxy Objects
+
+
+
+
The Proxy Constructor
+
The Proxy constructor is the %Proxy% intrinsic object and the initial value of the `Proxy` property of the global object. When called as a constructor it creates and initializes a new proxy exotic object. `Proxy` is not intended to be called as a function and will throw an exception when called in that manner.
+
+
+
+
Proxy ( _target_, _handler_ )
+
When `Proxy` is called with arguments _target_ and _handler_ performs the following steps:
+
+ 1. If NewTarget is *undefined*, throw a *TypeError* exception.
+ 1. Return ProxyCreate(_target_, _handler_).
+
+
+
+
+
+
+
Properties of the Proxy Constructor
+
The value of the [[Prototype]] internal slot of the `Proxy` constructor is the intrinsic object %FunctionPrototype% ().
+
The `Proxy` constructor does not have a `prototype` property because proxy exotic objects do not have a [[Prototype]] internal slot that requires initialization.
+
Besides the `length` property (whose value is 2), the `Proxy` constructor has the following properties:
+
+
+
+
Proxy.revocable ( _target_, _handler_ )
+
The `Proxy.revocable` function is used to create a revocable Proxy object. When `Proxy.revocable` is called with arguments _target_ and _handler_ the following steps are taken:
+
+ 1. Let _p_ be ? ProxyCreate(_target_, _handler_).
+ 1. Let _revoker_ be a new built-in function object as defined in .
+ 1. Set the [[RevocableProxy]] internal slot of _revoker_ to _p_.
+ 1. Let _result_ be ObjectCreate(%ObjectPrototype%).
+ 1. Perform CreateDataProperty(_result_, `"proxy"`, _p_).
+ 1. Perform CreateDataProperty(_result_, `"revoke"`, _revoker_).
+ 1. Return _result_.
+
+
+
+
+
Proxy Revocation Functions
+
A Proxy revocation function is an anonymous function that has the ability to invalidate a specific Proxy object.
+
Each Proxy revocation function has a [[RevocableProxy]] internal slot.
+
When a Proxy revocation function, _F_, is called the following steps are taken:
+
+ 1. Let _p_ be the value of _F_'s [[RevocableProxy]] internal slot.
+ 1. If _p_ is *null*, return *undefined*.
+ 1. Set the value of _F_'s [[RevocableProxy]] internal slot to *null*.
+ 1. Assert: _p_ is a Proxy object.
+ 1. Set the [[ProxyTarget]] internal slot of _p_ to *null*.
+ 1. Set the [[ProxyHandler]] internal slot of _p_ to *null*.
+ 1. Return *undefined*.
+
+
The `length` property of a Proxy revocation function is 0.
+
+
+
+
+
+
+
+
Module Namespace Objects
+
A Module Namespace Object is a module namespace exotic object that provides runtime property-based access to a module's exported bindings. There is no constructor function for Module Namespace Objects. Instead, such an object is created for each module that is imported by an |ImportDeclaration| that includes a |NameSpaceImport| (See ).
+
In addition to the properties specified in each Module Namespace Object has the following own properties:
+
+
+
+
@@toStringTag
+
The initial value of the @@toStringTag property is the String value `"Module"`.
+
This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.
+
+
+
+
+
[ @@iterator ] ( )
+
When the @@iterator method is called with no arguments, the following steps are taken:
+
+ 1. Let _N_ be the *this* value.
+ 1. If Type(_N_) is not Object, throw a *TypeError* exception.
+ 1. Return _N_.[[Enumerate]]().
+
+
The value of the `name` property of this function is `"[Symbol.iterator]"`.
+
+
+
+
+
+
+
Grammar Summary
+
+
+
+
Lexical Grammar
+
+
+
+
+
+
Expressions
+
+
+
+
+
+
Statements
+
+
+
+
+
+
Functions and Classes
+
+
+
+
+
+
Scripts and Modules
+
+
+
+
+
+
Number Conversions
+
+
+
+
+
+
Universal Resource Identifier Character Classes
+
+
+
+
+
+
Regular Expressions
+
+
+
+
+
+
+
Additional ECMAScript Features for Web Browsers
+
The ECMAScript language syntax and semantics defined in this annex are required when the ECMAScript host is a web browser. The content of this annex is normative but optional if the ECMAScript host is not a web browser.
+
+
This annex describes various legacy features and other characteristics of web browser based ECMAScript implementations. All of the language features and behaviours specified in this annex have one or more undesirable characteristics and in the absence of legacy usage would be removed from this specification. However, the usage of these features by large numbers of existing web pages means that web browsers must continue to support them. The specifications in this annex defined the requirements for interoperable implementations of these legacy features.
+
These features are not considered part of the core ECMAScript language. Programmers should not use or assume the existence of these features and behaviours when writing new ECMAScript code. ECMAScript implementations are discouraged from implementing these features unless the implementation is part of a web browser or is required to run the same legacy ECMAScript code that web browsers encounter.
+
+
+
+
+
Additional Syntax
+
+
+
+
Numeric Literals
+
The syntax and semantics of is extended as follows except that this extension is not allowed for strict mode code:
+ The MV of LegacyOctalIntegerLiteral :: `0` OctalDigit is the MV of |OctalDigit|.
+
+
+ The MV of LegacyOctalIntegerLiteral :: LegacyOctalIntegerLiteral OctalDigit is (the MV of |LegacyOctalIntegerLiteral| times 8) plus the MV of |OctalDigit|.
+
+
+ The MV of DecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral is the MV of |NonOctalDecimalIntegerLiteral|.
+
+
+ The MV of NonOctalDecimalIntegerLiteral :: `0` NonOctalDigit is the MV of |NonOctalDigit|.
+
+
+ The MV of NonOctalDecimalIntegerLiteral :: LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit is (the MV of |LegacyOctalLikeDecimalIntegerLiteral| times 10) plus the MV of |NonOctalDigit|.
+
+
+ The MV of NonOctalDecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral DecimalDigit is (the MV of |NonOctalDecimalIntegerLiteral| times 10) plus the MV of |DecimalDigit|.
+
+
+ The MV of LegacyOctalLikeDecimalIntegerLiteral :: `0` OctalDigit is the MV of |OctalDigit|.
+
+
+ The MV of LegacyOctalLikeDecimalIntegerLiteral :: LegacyOctalLikeDecimalIntegerLiteral OctalDigit is (the MV of |LegacyOctalLikeDecimalIntegerLiteral| times 10) plus the MV of |OctalDigit|.
+
+
+ The MV of NonOctalDigit :: `8` is 8.
+
+
+ The MV of NonOctalDigit :: `9` is 9.
+
+
+
+
+
+
+
+
String Literals
+
The syntax and semantics of is extended as follows except that this extension is not allowed for strict mode code:
This definition of |EscapeSequence| is not used in strict mode or when parsing |TemplateCharacter| ().
+
+
+
+
Static Semantics
+
+
+ The SV of EscapeSequence :: LegacyOctalEscapeSequence is the SV of the |LegacyOctalEscapeSequence|.
+
+
+ The SV of LegacyOctalEscapeSequence :: OctalDigit is the code unit whose value is the MV of the |OctalDigit|.
+
+
+ The SV of LegacyOctalEscapeSequence :: ZeroToThree OctalDigit is the code unit whose value is (8 times the MV of the |ZeroToThree|) plus the MV of the |OctalDigit|.
+
+
+ The SV of LegacyOctalEscapeSequence :: FourToSeven OctalDigit is the code unit whose value is (8 times the MV of the |FourToSeven|) plus the MV of the |OctalDigit|.
+
+
+ The SV of LegacyOctalEscapeSequence :: ZeroToThree OctalDigit OctalDigit is the code unit whose value is (64 (that is, 82) times the MV of the |ZeroToThree|) plus (8 times the MV of the first |OctalDigit|) plus the MV of the second |OctalDigit|.
+
+
+ The MV of ZeroToThree :: `0` is 0.
+
+
+ The MV of ZeroToThree :: `1` is 1.
+
+
+ The MV of ZeroToThree :: `2` is 2.
+
+
+ The MV of ZeroToThree :: `3` is 3.
+
+
+ The MV of FourToSeven :: `4` is 4.
+
+
+ The MV of FourToSeven :: `5` is 5.
+
+
+ The MV of FourToSeven :: `6` is 6.
+
+
+ The MV of FourToSeven :: `7` is 7.
+
+
+
+
+
+
+
+
HTML-like Comments
+
The syntax and semantics of is extended as follows except that this extension is not allowed when parsing source code using the goal symbol |Module|:
Similar to a |MultiLineComment| that contains a line terminator code point, a |SingleLineHTMLCloseComment| is considered to be a |LineTerminator| for purposes of parsing by the syntactic grammar.
+
+
+
+
+
Regular Expressions Patterns
+
The syntax of is modified and extended as follows. These changes introduce ambiguities that are broken by the ordering of grammar productions and by contextual information. When parsing using the following grammar, each alternative is considered only if previous production alternatives do not match.
+
This alternative pattern grammar and semantics only changes the syntax and semantics of BMP patterns. The following grammar extensions include productions parameterized with the [U] parameter. However, none of these extensions change the syntax of Unicode patterns recognized when parsing with the [U] parameter present on the goal symbol.
+
Syntax
+
+ Term[U] ::
+ [~U] ExtendedTerm
+ [+U] Assertion[U]
+ [+U] Atom[U]
+ [+U] Atom[U] Quantifier
+
+ ExtendedTerm ::
+ Assertion
+ AtomNoBrace Quantifier
+ Atom
+ QuantifiableAssertion Quantifier
+
+ AtomNoBrace ::
+ PatternCharacterNoBrace
+ `.`
+ `\` AtomEscape
+ CharacterClass
+ `(` Disjunction `)`
+ `(` `?` `:` Disjunction `)`
+
+ Atom[U] ::
+ PatternCharacter
+ `.`
+ `\` AtomEscape[?U]
+ CharacterClass[?U]
+ `(` Disjunction[?U] `)`
+ `(` `?` `:` Disjunction[?U] `)`
+
+ PatternCharacterNoBrace ::
+ SourceCharacter but not one of `^` `$` `\` `.` `*` `+` `?` `(` `)` `[` `]` `{` `}` `|`
+
+ PatternCharacter ::
+ SourceCharacter but not one of `^` `$` `\` `.` `*` `+` `?` `(` `)` `[` `]` `|`
+
+ QuantifiableAssertion ::
+ `(` `?` `=` Disjunction `)`
+ `(` `?` `!` Disjunction `)`
+
+ Assertion[U] ::
+ `^`
+ `$`
+ `\` `b`
+ `\` `B`
+ [+U] `(` `?` `=` Disjunction[U] `)`
+ [+U] `(` `?` `!` Disjunction[U] `)`
+ [~U] QuantifiableAssertion
+
+ AtomEscape[U] ::
+ [+U] DecimalEscape
+ [+U] CharacterEscape[U]
+ [+U] CharacterClassEscape
+ [~U] DecimalEscape but only if the integer value of DecimalEscape is <= _NCapturingParens_
+ [~U] CharacterClassEscape
+ [~U] CharacterEscape
+
+ CharacterEscape[U] ::
+ ControlEscape
+ `c` ControlLetter
+ HexEscapeSequence
+ RegExpUnicodeEscapeSequence[?U]
+ [~U] LegacyOctalEscapeSequence
+ IdentityEscape[?U]
+
+ IdentityEscape[U] ::
+ [+U] SyntaxCharacter
+ [+U] `/`
+ [~U] SourceCharacter but not `c`
+
+ NonemptyClassRanges[U] ::
+ ClassAtom[?U]
+ ClassAtom[?U] NonemptyClassRangesNoDash[?U]
+ [+U] ClassAtom[U] `-` ClassAtom[U] ClassRanges[U]
+ [~U] ClassAtomInRange `-` ClassAtomInRange ClassRanges
+
+ NonemptyClassRangesNoDash[U] ::
+ ClassAtom[?U]
+ ClassAtomNoDash[?U] NonemptyClassRangesNoDash[?U]
+ [+U] ClassAtomNoDash[U] `-` ClassAtom[U] ClassRanges[U]
+ [~U] ClassAtomNoDashInRange `-` ClassAtomInRange ClassRanges
+
+ ClassAtom[U] ::
+ `-`
+ ClassAtomNoDash[?U]
+
+ ClassAtomNoDash[U] ::
+ SourceCharacter but not one of `\` or `]` or `-`
+ `\` ClassEscape[?U]
+
+ ClassAtomInRange ::
+ `-`
+ ClassAtomNoDashInRange
+
+ ClassAtomNoDashInRange ::
+ SourceCharacter but not one of `\` or `]` or `-`
+ `\` ClassEscape but only if ClassEscape evaluates to a CharSet with exactly one character
+ `\` IdentityEscape
+
+ ClassEscape[U] ::
+ [+U] DecimalEscape
+ [+U] CharacterEscape[U]
+ [+U] CharacterClassEscape
+ [~U] DecimalEscape
+ `b`
+ [~U] CharacterClassEscape
+ [~U] CharacterEscape
+
+
+
When the same left hand sides occurs with both [+U] and [\~U] guards it is to control the disambiguation priority.
+
+
+
+
+
Pattern Semantics
+
The semantics of is extended as follows:
+
Within reference to “Atom :: `(` Disjunction `)` ” are to be interpreted as meaning “Atom :: `(` Disjunction `)` ” or “AtomNoBrace :: `(` Disjunction `)` ”.
+
Term () includes the following additional evaluation rule:
+
The production Term :: QuantifiableAssertion Quantifier evaluates the same as the production Term :: Atom Quantifier but with |QuantifiableAssertion| substituted for |Atom|.
+
Atom () evaluation rules for the |Atom| productions except for Atom :: PatternCharacter are also used for the |AtomNoBrace| productions, but with |AtomNoBrace| substituted for |Atom|. The following evaluation rule is also added:
+
The production AtomNoBrace :: PatternCharacterNoBrace evaluates as follows:
+
+ 1. Let _ch_ be the character represented by |PatternCharacterNoBrace|.
+ 1. Let _A_ be a one-element CharSet containing the character _ch_.
+ 1. Call CharacterSetMatcher(_A_, *false*) and return its Matcher result.
+
+
CharacterEscape () includes the following additional evaluation rule:
+
The production CharacterEscape :: LegacyOctalEscapeSequence evaluates by evaluating the SV of the |LegacyOctalEscapeSequence| (see ) and returning its character result.
+
ClassAtom () includes the following additional evaluation rules:
+
The production ClassAtomInRange :: `-` evaluates by returning the CharSet containing the one character `-`.
+
The production ClassAtomInRange :: ClassAtomNoDashInRange evaluates by evaluating |ClassAtomNoDashInRange| to obtain a CharSet and returning that CharSet.
+
ClassAtomNoDash () includes the following additional evaluation rules:
+
The production ClassAtomNoDashInRange :: SourceCharacter but not one of `\` or `]` or `-` evaluates by returning a one-element CharSet containing the character represented by |SourceCharacter|.
+
The production ClassAtomNoDashInRange :: `\` ClassEscape but only if…, evaluates by evaluating |ClassEscape| to obtain a CharSet and returning that CharSet.
+
The production ClassAtomNoDashInRange :: `\` IdentityEscape evaluates by returning the character represented by |IdentityEscape|.
+
+
+
+
+
+
+
Additional Built-in Properties
+
When the ECMAScript host is a web browser the following additional properties of the standard built-in objects are defined.
+
+
+
+
Additional Properties of the Global Object
+
The entries in are added to .
+
+
+
+
+
+ Intrinsic Name
+
+
+ Global Name
+
+
+ ECMAScript Language Association
+
+
+
+
+ %escape%
+
+
+ `escape`
+
+
+ The `escape` function ()
+
+
+
+
+ %unescape%
+
+
+ `unescape`
+
+
+ The `unescape` function ()
+
+
+
+
+
+
+
+
+
escape (_string_)
+
The `escape` function is a property of the global object. It computes a new version of a String value in which certain code units have been replaced by a hexadecimal escape sequence.
+
For those code units being replaced whose value is `0x00FF` or less, a two-digit escape sequence of the form %xx is used. For those characters being replaced whose code unit value is greater than `0x00FF`, a four-digit escape sequence of the form %uxxxx is used.
+
The `escape` function is the %escape% intrinsic object. When the `escape` function is called with one argument _string_, the following steps are taken:
+
+ 1. Let _string_ be ? ToString(_string_).
+ 1. Let _length_ be the number of code units in _string_.
+ 1. Let _R_ be the empty string.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ < _length_,
+ 1. Let _char_ be the code unit (represented as a 16-bit unsigned integer) at index _k_ within _string_.
+ 1. If _char_ is one of the code units in `"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./"`, then
+ 1. Let _S_ be a String containing the single code unit _char_.
+ 1. Else if _char_ ≥ 256, then
+ 1. Let _S_ be a String containing six code units "%uwxyz" where _wxyz_ are the code units of the four hexadecimal digits encoding the value of _char_.
+ 1. Else, _char_ < 256
+ 1. Let _S_ be a String containing three code units "%xy" where _xy_ are the code units of two hexadecimal digits encoding the value of _char_.
+ 1. Let _R_ be a new String value computed by concatenating the previous value of _R_ and _S_.
+ 1. Increase _k_ by 1.
+ 1. Return _R_.
+
+
+
The encoding is partly based on the encoding described in RFC 1738, but the entire encoding specified in this standard is described above without regard to the contents of RFC 1738. This encoding does not reflect changes to RFC 1738 made by RFC 3986.
+
+
+
+
+
+
unescape (_string_)
+
The `unescape` function is a property of the global object. It computes a new version of a String value in which each escape sequence of the sort that might be introduced by the `escape` function is replaced with the code unit that it represents.
+
The `unescape` function is the %unescape% intrinsic object. When the `unescape` function is called with one argument _string_, the following steps are taken:
+
+ 1. Let _string_ be ? ToString(_string_).
+ 1. Let _length_ be the number of code units in _string_.
+ 1. Let _R_ be the empty String.
+ 1. Let _k_ be 0.
+ 1. Repeat, while _k_ ≠ _length_
+ 1. Let _c_ be the code unit at index _k_ within _string_.
+ 1. If _c_ is `%`, then
+ 1. If _k_ ≤ _length_-6 and the code unit at index _k_+1 within _string_ is `u` and the four code units at indices _k_+2, _k_+3, _k_+4, and _k_+5 within _string_ are all hexadecimal digits, then
+ 1. Let _c_ be the code unit whose value is the integer represented by the four hexadecimal digits at indices _k_+2, _k_+3, _k_+4, and _k_+5 within _string_.
+ 1. Increase _k_ by 5.
+ 1. Else if _k_ ≤ _length_-3 and the two code units at indices _k_+1 and _k_+2 within _string_ are both hexadecimal digits, then
+ 1. Let _c_ be the code unit whose value is the integer represented by two zeroes plus the two hexadecimal digits at indices _k_+1 and _k_+2 within _string_.
+ 1. Increase _k_ by 2.
+ 1. Let _R_ be a new String value computed by concatenating the previous value of _R_ and _c_.
+ 1. Increase _k_ by 1.
+ 1. Return _R_.
+
+
+
+
+
+
+
Additional Properties of the Object.prototype Object
+
+
+
+
Object.prototype.__proto__
+
Object.prototype.__proto__ is an accessor property with attributes { [[Enumerable]]: *false*, [[Configurable]]: *true* }. The [[Get]] and [[Set]] attributes are defined as follows
+
+
+
+
get Object.prototype.__proto__
+
The value of the [[Get]] attribute is a built-in function that requires no arguments. It performs the following steps:
+
+ 1. Let _O_ be ? ToObject(*this* value).
+ 1. Return _O_.[[GetPrototypeOf]]().
+
+
+
+
+
+
set Object.prototype.__proto__
+
The value of the [[Set]] attribute is a built-in function that takes an argument _proto_. It performs the following steps:
+
+ 1. Let _O_ be ? RequireObjectCoercible(*this* value).
+ 1. If Type(_proto_) is neither Object nor Null, return *undefined*.
+ 1. If Type(_O_) is not Object, return *undefined*.
+ 1. Let _status_ be ? _O_.[[SetPrototypeOf]](_proto_).
+ 1. If _status_ is *false*, throw a *TypeError* exception.
+ 1. Return *undefined*.
+
+
+
+
+
+
+
+
Additional Properties of the String.prototype Object
+
+
+
+
String.prototype.substr (_start_, _length_)
+
The `substr` method takes two arguments, _start_ and _length_, and returns a substring of the result of converting the *this* object to a String, starting from index _start_ and running for _length_ code units (or through the end of the String if _length_ is *undefined*). If _start_ is negative, it is treated as (_sourceLength_+_start_) where _sourceLength_ is the length of the String. The result is a String value, not a String object. The following steps are taken:
+
+ 1. Let _O_ be RequireObjectCoercible(*this* value).
+ 1. Let _S_ be ? ToString(_O_).
+ 1. Let _intStart_ be ? ToInteger(_start_).
+ 1. If _length_ is *undefined*, let _end_ be *+∞*; otherwise let _end_ be ? ToInteger(_length_).
+ 1. Let _size_ be the number of code units in _S_.
+ 1. If _intStart_ < 0, let _intStart_ be max(_size_ + _intStart_,0).
+ 1. Let _resultLength_ be min(max(_end_,0), _size_ - _intStart_).
+ 1. If _resultLength_ ≤ 0, return the empty String `""`.
+ 1. Return a String containing _resultLength_ consecutive code units from _S_ beginning with the code unit at index _intStart_.
+
+
+
The `substr` function is intentionally generic; it does not require that its *this* value be a String object. Therefore it can be transferred to other kinds of objects for use as a method.
+
+
+
+
+
+
String.prototype.anchor ( _name_ )
+
When the `anchor` method is called with argument _name_, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"a"`, `"name"`, _name_).
+
+
+
+
+
The abstract operation CreateHTML is called with arguments _string_, _tag_, _attribute_, and _value_. The arguments _tag_ and _attribute_ must be String values. The following steps are taken:
+
+ 1. Let _str_ be RequireObjectCoercible(_string_).
+ 1. Let _S_ be ? ToString(_str_).
+ 1. Let _p1_ be the String value that is the concatenation of `"<"` and _tag_.
+ 1. If _attribute_ is not the empty String, then
+ 1. Let _V_ be ? ToString(_value_).
+ 1. Let _escapedV_ be the String value that is the same as _V_ except that each occurrence of the code unit 0x0022 (QUOTATION MARK) in _V_ has been replaced with the six code unit sequence `"""`.
+ 1. Let _p1_ be the String value that is the concatenation of the following String values:
+ * The String value of _p1_
+ * Code unit 0x0020 (SPACE)
+ * The String value of _attribute_
+ * Code unit 0x003D (EQUALS SIGN)
+ * Code unit 0x0022 (QUOTATION MARK)
+ * The String value of _escapedV_
+ * Code unit 0x0022 (QUOTATION MARK)
+ 1. Let _p2_ be the String value that is the concatenation of _p1_ and `">"`.
+ 1. Let _p3_ be the String value that is the concatenation of _p2_ and _S_.
+ 1. Let _p4_ be the String value that is the concatenation of _p3_, `"</"`, _tag_, and `">"`.
+ 1. Return _p4_.
+
+
+
+
+
+
+
String.prototype.big ()
+
When the `big` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"big"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.blink ()
+
When the `blink` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"blink"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.bold ()
+
When the `bold` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"b"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.fixed ()
+
When the `fixed` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"tt"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.fontcolor ( _color_ )
+
When the `fontcolor` method is called with argument _color_, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"font"`, `"color"`, _color_).
+
+
+
+
+
+
String.prototype.fontsize ( _size_ )
+
When the `fontsize` method is called with argument _size_, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"font"`, `"size"`, _size_).
+
+
+
+
+
+
String.prototype.italics ()
+
When the `italics` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"i"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.link ( _url_ )
+
When the `link` method is called with argument _url_, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"a"`, `"href"`, _url_).
+
+
+
+
+
+
String.prototype.small ()
+
When the `small` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"small"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.strike ()
+
When the `strike` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"strike"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.sub ()
+
When the `sub` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"sub"`, `""`, `""`).
+
+
+
+
+
+
String.prototype.sup ()
+
When the `sup` method is called with no arguments, the following steps are taken:
+
+ 1. Let _S_ be the *this* value.
+ 1. Return CreateHTML(_S_, `"sup"`, `""`, `""`).
+
+
+
+
+
+
+
Additional Properties of the Date.prototype Object
+
+
+
+
Date.prototype.getYear ( )
+
+
The `getFullYear` method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”
+
+
When the `getYear` method is called with no arguments, the following steps are taken:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, return *NaN*.
+ 1. Return YearFromTime(LocalTime(_t_)) - 1900.
+
+
+
+
+
+
Date.prototype.setYear (_year_)
+
+
The `setFullYear` method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”
+
+
When the `setYear` method is called with one argument _year_, the following steps are taken:
+
+ 1. Let _t_ be this time value.
+ 1. ReturnIfAbrupt(_t_).
+ 1. If _t_ is *NaN*, let _t_ be *+0*; otherwise, let _t_ be LocalTime(_t_).
+ 1. Let _y_ be ? ToNumber(_year_).
+ 1. If _y_ is *NaN*, set the [[DateValue]] internal slot of this Date object to *NaN* and return *NaN*.
+ 1. If _y_ is not *NaN* and 0 ≤ ToInteger(_y_) ≤ 99, let _yyyy_ be ToInteger(_y_) + 1900.
+ 1. Else, let _yyyy_ be _y_.
+ 1. Let _d_ be MakeDay(_yyyy_, MonthFromTime(_t_), DateFromTime(_t_)).
+ 1. Let _date_ be UTC(MakeDate(_d_, TimeWithinDay(_t_))).
+ 1. Set the [[DateValue]] internal slot of this Date object to TimeClip(_date_).
+ 1. Return the value of the [[DateValue]] internal slot of this Date object.
+
+
+
+
+
+
Date.prototype.toGMTString ( )
+
+
The property `toUTCString` is preferred. The `toGMTString` property is provided principally for compatibility with old code. It is recommended that the `toUTCString` property be used in new ECMAScript code.
+
+
The function object that is the initial value of `Date.prototype.toGMTString` is the same function object that is the initial value of `Date.prototype.toUTCString`.
+
+
+
+
+
+
Additional Properties of the RegExp.prototype Object
+
+
+
+
RegExp.prototype.compile (_pattern_, _flags_ )
+
When the `compile` method is called with arguments _pattern_ and _flags_, the following steps are taken:
+
+ 1. Let _O_ be the *this* value.
+ 1. If Type(_O_) is not Object or Type(_O_) is Object and _O_ does not have a [[RegExpMatcher]] internal slot, then
+ 1. Throw a *TypeError* exception.
+ 1. If Type(_pattern_) is Object and _pattern_ has a [[RegExpMatcher]] internal slot, then
+ 1. If _flags_ is not *undefined*, throw a *TypeError* exception.
+ 1. Let _P_ be the value of _pattern_'s [[OriginalSource]] internal slot.
+ 1. Let _F_ be the value of _pattern_'s [[OriginalFlags]] internal slot.
+ 1. Else,
+ 1. Let _P_ be _pattern_.
+ 1. Let _F_ be _flags_.
+ 1. Return RegExpInitialize(_O_, _P_, _F_).
+
+
+
The `compile` method completely reinitializes the *this* object RegExp with a new pattern and flags. An implementation may interpret use of this method as an assertion that the resulting RegExp object will be used multiple times and hence is a candidate for extra optimization.
+
+
+
+
+
+
+
+
Other Additional Features
+
+
+
+
__proto__ Property Names in Object Initializers
+
The following Early Error rule is added to those in :
+ It is a Syntax Error if PropertyNameList of |PropertyDefinitionList| contains any duplicate entries for `"__proto__"` and at least two of those entries were obtained from productions of the form PropertyDefinition : PropertyName `:` AssignmentExpression .
+
+
+
+
The List returned by PropertyNameList does not include string literal property names defined as using a |ComputedPropertyName|.
+
+
In the PropertyDefinitionEvaluation algorithm for the production
+
+ PropertyDefinition : PropertyName `:` AssignmentExpression
+
+ is replaced with the following definition:
+ PropertyDefinition : PropertyName `:` AssignmentExpression
+
+ 1. Let _propKey_ be the result of evaluating |PropertyName|.
+ 1. ReturnIfAbrupt(_propKey_).
+ 1. Let _exprValueRef_ be the result of evaluating |AssignmentExpression|.
+ 1. Let _propValue_ be ? GetValue(_exprValueRef_).
+ 1. If _propKey_ is the String value `"__proto__"` and if IsComputedPropertyKey(_propKey_) is *false*, then
+ 1. If Type(_propValue_) is either Object or Null, then
+ 1. Return _object_.[[SetPrototypeOf]](_propValue_).
+ 1. Return NormalCompletion(~empty~).
+ 1. If IsAnonymousFunctionDefinition(|AssignmentExpression|) is *true*, then
+ 1. Let _hasNameProperty_ be ? HasOwnProperty(_propValue_, `"name"`).
+ 1. If _hasNameProperty_ is *false*, perform SetFunctionName(_propValue_, _propKey_).
+ 1. Assert: _enumerable_ is *true*.
+ 1. Return CreateDataPropertyOrThrow(_object_, _propKey_, _propValue_).
+
+
+
+
+
+
Labelled Function Declarations
+
Prior to ECMAScript 2015, the specification of |LabelledStatement| did not allow for the association of a statement label with a |FunctionDeclaration|. However, a labelled |FunctionDeclaration| was an allowable extension for non-strict code and most browser-hosted ECMAScript implementations supported that extension. In ECMAScript 2015, the grammar productions for |LabelledStatement| permits use of |FunctionDeclaration| as a |LabelledItem| but includes an Early Error rule that produces a Syntax Error if that occurs. For web browser compatibility, that rule is modified with the addition of the highlighted text:
+ LabelledItem : FunctionDeclaration
+
+
+ It is a Syntax Error if any strict mode source code matches this rule.
+
+
+
+
+
+
+
Block-Level Function Declarations Web Legacy Compatibility Semantics
+
Prior to ECMAScript 2015, the ECMAScript specification did not define the occurrence of a |FunctionDeclaration| as an element of a |Block| statement's |StatementList|. However, support for that form of |FunctionDeclaration| was an allowable extension and most browser-hosted ECMAScript implementations permitted them. Unfortunately, the semantics of such declarations differ among those implementations. Because of these semantic differences, existing web ECMAScript code that uses |Block| level function declarations is only portable among browser implementation if the usage only depends upon the semantic intersection of all of the browser implementations for such declarations. The following are the use cases that fall within that intersection semantics:
+
+
+ A function is declared and only referenced within a single block
+
+
+ A |FunctionDeclaration| whose |BindingIdentifier| is the name _f_ occurs exactly once within the function code of an enclosing function _g_ and that declaration is nested within a |Block|.
+
+
+ No other declaration of _f_ that is not a `var` declaration occurs within the function code of _g_
+
+
+ All occurrences of _f_ as an |IdentifierReference| are within the |StatementList| of the |Block| containing the declaration of _f_.
+
+
+
+
+ A function is declared and possibly used within a single |Block| but also referenced by an inner function definition that is not contained within that same |Block|.
+
+
+ A |FunctionDeclaration| whose |BindingIdentifier| is the name _f_ occurs exactly once within the function code of an enclosing function _g_ and that declaration is nested within a |Block|.
+
+
+ No other declaration of _f_ that is not a `var` declaration occurs within the function code of _g_
+
+
+ There may be occurrences of _f_ as an |IdentifierReference| within the |StatementList| of the |Block| containing the declaration of _f_.
+
+
+ There is at least one occurrence of _f_ as an |IdentifierReference| within another function _h_ that is nested within _g_ and no other declaration of _f_ shadows the references to _f_ from within _h_.
+
+
+ All invocations of _h_ occur after the declaration of _f_ has been evaluated.
+
+
+
+
+ A function is declared and possibly used within a single block but also referenced within subsequent blocks.
+
+
+ A |FunctionDeclaration| whose |BindingIdentifier| is the name _f_ occurs exactly once within the function code of an enclosing function _g_ and that declaration is nested within a |Block|.
+
+
+ No other declaration of _f_ that is not a `var` declaration occurs within the function code of _g_
+
+
+ There may be occurrences of _f_ as an |IdentifierReference| within the |StatementList| of the |Block| containing the declaration of _f_.
+
+
+ There is at least one occurrence of _f_ as an |IdentifierReference| within the function code of _g_ that lexically follows the |Block| containing the declaration of _f_.
+
+
+
+
+
The first use case is interoperable with the semantics of |Block| level function declarations provided by ECMAScript 2015. Any pre-existing ECMAScript code that employs that use case will operate using the Block level function declarations semantics defined by clauses 9, 13, and 14 of this specification.
+
ECMAScript 2015 interoperability for the second and third use cases requires the following extensions to the clause , clause , clause and clause semantics.
+
If an ECMAScript implementation has a mechanism for reporting diagnostic warning messages, a warning should be produced when code contains a |FunctionDeclaration| for which these compatibility semantics are applied and introduce observable differences from non-compatibility semantics. For example, if a var binding is not introduced because its introduction would create an early error, a warning message should not be produced.
+
+
Changes to FunctionDeclarationInstantiation
+
During FunctionDeclarationInstantiation () the following steps are performed in place of step 29:
+
+ 1. If _strict_ is *false*, then
+ 1. For each |FunctionDeclaration| _f_ that is directly contained in the |StatementList| of a |Block|, |CaseClause|, or |DefaultClause|,
+ 1. Let _F_ be StringValue of the |BindingIdentifier| of |FunctionDeclaration| _f_.
+ 1. If replacing the |FunctionDeclaration| _f_ with a |VariableStatement| that has _F_ as a |BindingIdentifier| would not produce any Early Errors for _func_ and _F_ is not an element of BoundNames of _argumentsList_, then
+ 1. NOTE A var binding for _F_ is only instantiated here if it is neither a VarDeclaredName, the name of a formal parameter, or another |FunctionDeclaration|.
+ 1. If _instantiatedVarNames_ does not contain _F_, then
+ 1. Let _status_ be _varEnvRec_.CreateMutableBinding(_F_).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Perform _varEnvRec_.InitializeBinding(_F_, *undefined*).
+ 1. Append _F_ to _instantiatedVarNames_.
+ 1. When the |FunctionDeclaration| _f_ is evaluated, perform the following steps in place of the |FunctionDeclaration| Evaluation algorithm provided in :
+ 1. Let _fenv_ be the running execution context's VariableEnvironment.
+ 1. Let _benv_ be the running execution context's LexicalEnvironment.
+ 1. Let _fobj_ be _benv_.GetBindingValue(_F_, *false*).
+ 1. Assert: _fobj_ is never an abrupt completion.
+ 1. Let _status_ be _fenv_.SetMutableBinding(_F_, _fobj_, *false*).
+ 1. Assert: _status_ is never an abrupt completion.
+ 1. Return NormalCompletion(~empty~).
+
+
+
+
Changes to GlobalDeclarationInstantiation
+
During GlobalDeclarationInstatiation () the following steps are performed in place of step 14:
+
+ 1. Let _declaredFunctionOrVarNames_ be an empty List.
+ 1. Append to _declaredFunctionOrVarNames_ the elements of _declaredFunctionNames_.
+ 1. Append to _declaredFunctionOrVarNames_ the elements of _declaredVarNames_.
+ 1. For each |FunctionDeclaration| _f_ that is directly contained in the |StatementList| of a |Block|, |CaseClause|, or |DefaultClause| Contained within script,
+ 1. Let _F_ be StringValue of the |BindingIdentifier| of |FunctionDeclaration| _f_.
+ 2. If replacing the |FunctionDeclaration| _f_ with a |VariableStatement| that has _F_ as a |BindingIdentifier| would not produce any Early Errors for script, then
+ 1. If _envRec_.HasLexicalDeclaration(_F_) is *false*, then
+ 1. Let _fnDefinable_ be ? _envRec_.CanDeclareGlobalFunction(_F_).
+ 3. If _fnDefinable_ is *true*, then
+ 1. NOTE A var binding for _F_ is only instantiated here if it is neither a VarDeclaredName nor the name of another |FunctionDeclaration|.
+ 2. If _declaredFunctionOrVarNames_ does not contain _F_, then
+ 1. Let _status_ be ? _envRec_.CreateGlobalFunctionBinding(_F_, *undefined*, *false*).
+ 1. Append _F_ to _declaredFunctionOrVarNames_.
+ 3. When the |FunctionDeclaration| _f_ is evaluated, perform the following steps in place of the |FunctionDeclaration| Evaluation algorithm provided in :
+ 1. Let _genv_ be the running execution context’s VariableEnvironment.
+ 2. Let _benv_ be the running execution context’s LexicalEnvironment.
+ 3. Let _fobj_ be _benv_.GetBindingValue(_F_, *false*).
+ 4. Assert: _fobj_ is never an abrupt completion.
+ 5. Let _status_ be ? _genv_.SetMutableBinding(_F_, _fobj_, *false*).
+ 7. Return NormalCompletion(~empty~).
+
+
+
+
Changes to EvalDeclarationInstantiation
+
During EvalDeclarationInstantiation () the following steps are performed in place of step 9:
+
+ 1. If _strict_ is *false*, then
+ 1. Let _declaredFunctionOrVarNames_ be an empty List.
+ 1. Append to _declaredFunctionOrVarNames_ the elements of _declaredFunctionNames_.
+ 1. Append to _declaredFunctionOrVarNames_ the elements of _declaredVarNames_.
+ 1. For each |FunctionDeclaration| _f_ that is directly contained in the |StatementList| of a |Block|, |CaseClause|, or |DefaultClause| Contained within _body_,
+ 1. Let _F_ be StringValue of the |BindingIdentifier| of |FunctionDeclaration| _f_.
+ 2. If replacing the |FunctionDeclaration| _f_ with a |VariableStatement| that has _F_ as a |BindingIdentifier| would not produce any Early Errors for _body_, then
+ 1. Let _bindingExists_ be *false*.
+ 3. Let _thisLex_ be _lexEnv_.
+ 4. Assert: the following loop will terminate.
+ 5. Repeat while _thisLex_ is not the same as _varEnv_,
+ 1. Let _thisEnvRec_ be _thisLex_'s EnvironmentRecord.
+ 2. If _thisEnvRec_ is not an object Environment Record, then
+ 1. If _thisEnvRec_.HasBinding(_F_) is *true*, then
+ 1. Let _bindingExists_ be *true*.
+ 1. Let _thisLex_ be _thisLex_'s outer environment reference.
+ 6. If _bindingExists_ is *false* and _varEnvRec_ is a global Environment Record, then
+ 1. If _varEnvRec_.HasLexicalDeclaration(_F_) is *false*, then
+ 1. Let _fnDefinable_ be ? _varEnvRec_.CanDeclareGlobalFunction(_F_).
+ 1. Else,
+ 1. Let _fnDefinable_ be *false*.
+ 1. Else,
+ 1. Let _fnDefinable_ be *true*.
+ 7. If _bindingExists_ is *false* and _fnDefinable_ is *true*, then
+ 1. If _declaredFunctionOrVarNames_ does not contain _F_, then
+ 1. If _varEnvRec_ is a global Environment Record, then
+ 1. Let _status_ be ? _varEnvRec_.CreateGlobalFunctionBinding(_F_, *undefined*, *true*).
+ 1. Else,
+ 1. Let _bindingExists_ be _varEnvRec_.HasBinding(_F_).
+ 1. If _bindingExists_ is *false*, then
+ 1. Let _status_ be _varEnvRec_.CreateMutableBinding(_F_, *true*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Let _status_ be _varEnvRec_.InitializeBinding(_F_, *undefined*).
+ 1. Assert: _status_ is not an abrupt completion.
+ 1. Append _F_ to _declaredFunctionOrVarNames_.
+ 2. When the |FunctionDeclaration| _f_ is evaluated, perform the following steps in place of the |FunctionDeclaration| Evaluation algorithm provided in :
+ 1. Let _genv_ be the running execution context’s VariableEnvironment.
+ 2. Let _benv_ be the running execution context’s LexicalEnvironment.
+ 3. Let _fobj_ be _benv_.GetBindingValue(_F_, *false*).
+ 4. Assert: _fobj_ is never an abrupt completion.
+ 5. Let _status_ be ? _genv_.SetMutableBinding(_F_, _fobj_, *false*).
+ 7. Return NormalCompletion(~empty~).
+
+
+
+
+
+
+
FunctionDeclarations in IfStatement Statement Clauses
+
The following rules for |IfStatement| augment those in :
The above rules are only applied when parsing code that is not strict mode code. If any such code is match by one of these rules subsequent processing of that code takes places as if each matching occurrence of |FunctionDeclaration[?Yield]| was the sole |StatementListItem| of a |BlockStatement| occupying that position in the source code. The semantics of such a synthetic |BlockStatement| includes the web legacy compatibility semantics specified in .
+
+
+
+
+
VariableStatements in Catch blocks
+
The content of subclause is replaced with the following:
+ Catch : `catch` `(` CatchParameter `)` Block
+
+
+ It is a Syntax Error if BoundNames of |CatchParameter| contains any duplicate elements.
+
+
+ It is a Syntax Error if any element of the BoundNames of |CatchParameter| also occurs in the LexicallyDeclaredNames of |Block|.
+
+
+ It is a Syntax Error if any element of the BoundNames of |CatchParameter| also occurs in the VarDeclaredNames of |Block| unless |CatchParameter| is CatchParameter : BindingIdentifier and that element is only bound by a |VariableStatement|, the |VariableDeclarationList| of a for statement, or the |ForBinding| of a for-in statement.
+
+
+
+
The |Block| of a |Catch| clause may contain `var` declarations that bind a name that is also bound by the |CatchParameter|. At runtime, such bindings are instantiated in the VariableDeclarationEnvironment. They do not shadow the same-named bindings introduced by the |CatchParameter| and hence the |Initializer| for such `var` declarations will assign to the corresponding catch parameter rather than the `var` binding. The relaxation of the normal static semantic rule does not apply to names only bound by for-of statements.
+
+
This modified behaviour also applies to `var` and `function` declarations introduced by direct evals contained within the |Block| of a |Catch| clause. This change is accomplished by modify the algorithm of as follows:
+
Step 5.d.ii.2.a.i is replaced by:
+
+ 1. If _thisEnvRec_ is not the Environment Record for a |Catch| clause, throw a *SyntaxError* exception.
+ 1. If _name_ is bound by any syntactic form other than a |FunctionDeclaration|, a |VariableStatement|, the |VariableDeclarationList| of a for statement, or the |ForBinding| of a for-in statement, throw a *SyntaxError* exception.
+
+
Step 9.d.ii.4.b.i.i is replaced by:
+
+ 1. If _thisEnvRec_ is not the Environment Record for a |Catch| clause, let _bindingExists_ be *true*.
+
+
+
+
+
+
+
+
The Strict Mode of ECMAScript
+
The strict mode restriction and exceptions
+
+
+ `implements`, `interface`, `let`, `package`, `private`, `protected`, `public`, `static`, and `yield` are reserved words within strict mode code. ().
+
+
+ A conforming implementation, when processing strict mode code, may not extend the syntax of |NumericLiteral| () to include |LegacyOctalIntegerLiteral| as described in .
+
+
+ A conforming implementation, when processing strict mode code, may not extend the syntax of |EscapeSequence| to include |LegacyOctalEscapeSequence| as described in .
+
+
+ Assignment to an undeclared identifier or otherwise unresolvable reference does not create a property in the global object. When a simple assignment occurs within strict mode code, its |LeftHandSideExpression| must not evaluate to an unresolvable Reference. If it does a *ReferenceError* exception is thrown (). The |LeftHandSideExpression| also may not be a reference to a data property with the attribute value {[[Writable]]:*false*}, to an accessor property with the attribute value {[[Set]]:*undefined*}, nor to a non-existent property of an object whose [[Extensible]] internal slot has the value *false*. In these cases a `TypeError` exception is thrown ().
+
+
+ The identifier `eval` or `arguments` may not appear as the |LeftHandSideExpression| of an Assignment operator () or of a |PostfixExpression| () or as the |UnaryExpression| operated upon by a Prefix Increment () or a Prefix Decrement () operator.
+
+
+ Arguments objects for strict mode functions define non-configurable accessor properties named `"caller"` and `"callee"` which throw a *TypeError* exception on access ().
+
+
+ Arguments objects for strict mode functions do not dynamically share their array indexed property values with the corresponding formal parameter bindings of their functions. ().
+
+
+ For strict mode functions, if an arguments object is created the binding of the local identifier `arguments` to the arguments object is immutable and hence may not be the target of an assignment expression. ().
+
+
+ It is a *SyntaxError* if the |IdentifierName| `eval` or the |IdentifierName| `arguments` occurs as a |BindingIdentifier| within strict mode code ().
+
+
+ Strict mode eval code cannot instantiate variables or functions in the variable environment of the caller to eval. Instead, a new variable environment is created and that environment is used for declaration binding instantiation for the eval code ().
+
+
+ If *this* is evaluated within strict mode code, then the *this* value is not coerced to an object. A *this* value of *null* or *undefined* is not converted to the global object and primitive values are not converted to wrapper objects. The *this* value passed via a function call (including calls made using `Function.prototype.apply` and `Function.prototype.call`) do not coerce the passed this value to an object (, , ).
+
+
+ When a `delete` operator occurs within strict mode code, a *SyntaxError* is thrown if its |UnaryExpression| is a direct reference to a variable, function argument, or function name ().
+
+
+ When a `delete` operator occurs within strict mode code, a *TypeError* is thrown if the property to be deleted has the attribute { [[Configurable]]:*false* } ().
+
+
+ Strict mode code may not include a |WithStatement|. The occurrence of a |WithStatement| in such a context is a *SyntaxError* ().
+
+
+ It is a *SyntaxError* if a |TryStatement| with a |Catch| occurs within strict mode code and the |Identifier| of the |Catch| production is `eval` or `arguments` ().
+
+
+ It is a *SyntaxError* if the same |BindingIdentifier| appears more than once in the |FormalParameters| of a strict mode function. An attempt to create such a function using a `Function` or `Generator` constructor is a *SyntaxError* (, ).
+
+
+ An implementation may not extend, beyond that defined in this specification, the meanings within strict mode functions of properties named `caller` or `arguments` of function instances. ECMAScript code may not create or modify properties with these names on function objects that correspond to strict mode functions ().
+
+
+
+
+
+
+
Corrections and Clarifications in ECMAScript 2015 with Possible Compatibility Impact
+
- Edition 5 and 5.1 used a property existence test to determine whether a global object property corresponding to a new global declaration already existed. ECMAScript 2015 uses an own property existence test. This corresponds to what has been most commonly implemented by web browsers.
+
: The 5th Edition moved the capture of the current array length prior to the integer conversion of the array index or new length value. However, the captured length value could become invalid if the conversion process has the side-effect of changing the array length. ECMAScript 2015 specifies that the current array length must be captured after the possible occurrence of such side-effects.
+
: Previous editions permitted the TimeClip abstract operation to return either +0 or -0 as the representation of a 0 time value. ECMAScript 2015 specifies that +0 always returned. This means that for ECMAScript 2015 the time value of a Date object is never observably -0 and methods that return time values never return -0.
+
: If a time zone offset is not present, the local time zone is used. Edition 5.1 incorrectly stated that a missing time zone should be interpreted as `"z"`.
+
: If the year cannot be represented using the Date Time String Format specified in a RangeError exception is thrown. Previous editions did not specify the behaviour for that case.
+
: Previous editions did not specify the value returned by Date.prototype.toString when this time value is NaN. ECMAScript 2015 specifies the result to be the String value is `"Invalid Date"`.
+
, : Any LineTerminator code points in the value of the `source` property of an RegExp instance must be expressed using an escape sequence. Edition 5.1 only required the escaping of `"/"`.
+
, : In previous editions, the specifications for `String.prototype.match` and `String.prototype.replace` was incorrect for cases where the pattern argument was a RegExp value whose `global` is flag set. The previous specifications stated that for each attempt to match the pattern, if `lastIndex` did not change it should be incremented by 1. The correct behaviour is that `lastIndex` should be incremented by one only if the pattern matched the empty string.
+
, : Previous editions did not specify how a *NaN* value returned by a _comparefn_ was interpreted by `Array.prototype.sort`. ECMAScript 2015 specifies that such as value is treated as if +0 was returned from the _comparefn_. ECMAScript 2015 also specifies that ToNumber is applied to the result returned by a _comparefn_. In previous editions, the effect of a _comparefn_ result that is not a Number value was implementation dependent. In practice, implementations call ToNumber.
+
+
+
+
+
Additions and Changes That Introduce Incompatibilities with Prior Editions
+
: In ECMAScript 2015, ToNumber applied to a String value now recognizes and converts |BinaryIntegerLiteral| and |OctalIntegerLiteral| numeric strings. In previous editions such strings were converted to *NaN*,
+
: In ECMAScript 2015, Function calls are not allowed to return a Reference value.
+
: In ECMAScript 2015, the valid code points for an |IdentifierName| are specified in terms of the Unicode properties “ID_Start” and “ID_Continue”. In previous editions, the valid |IdentifierName| or |Identifier| code points were specified by enumerating various Unicode code point categories.
+
: In ECMAScript 2015, Automatic Semicolon Insertion adds a semicolon at the end of a do-while statement if the semicolon is missing. This change aligns the specification with the actual behaviour of most existing implementations.
+
: In ECMAScript 2015, it is no longer an early error to have duplicate property names in Object Initializers.
+
: In ECMAScript 2015, strict mode code containing an assignment to an immutable binding such as the function name of a |FunctionExpression| does not produce an early error. Instead it produces a runtime error.
+
: In ECMAScript 2015, a |StatementListItem| beginning with the token `let` followed by the token `[` is the start of a |LexicalDeclaration|. In previous editions such a sequence would be the start of an |ExpressionStatement|.
+
: In ECMAScript 2015, the normal completion value of an |IfStatement| is never the value ~empty~. If no |Statement| part is evaluated or if the evaluated |Statement| part produces a normal completion whose value is ~empty~, the completion value of the |IfStatement| is *undefined*.
+
: In ECMAScript 2015, if the `(` token of a for statement is immediately followed by the token sequence `let [` then the `let` is treated as the start of a |LexicalDeclaration|. In previous editions such a token sequence would be the start of an |Expression|.
+
: In ECMAScript 2015, if the ( token of a for-in statement is immediately followed by the token sequence `let [` then the `let` is treated as the start of a |ForDeclaration|. In previous editions such a token sequence would be the start of an |LeftHandSideExpression|.
+
: Prior to ECMAScript 2015, an initialization expression could appear as part of the |VariableDeclaration| that precedes the `in` keyword. The value of that expression was always discarded. In ECMAScript 2015, the _ForBinding_ in that same position does not allow the occurrence of such an initializer.
+
: In ECMAScript 2015, the completion value of an |IterationStatement| is never the value ~empty~. If the |Statement| part of an |IterationStatement| is not evaluated or if the final evaluation of the |Statement| part produces a completion whose value is ~empty~, the completion value of the |IterationStatement| is *undefined*.
+
: In ECMAScript 2015, the normal completion value of a |WithStatement| is never the value ~empty~. If evaluation of the |Statement| part of a |WithStatement| produces a normal completion whose value is ~empty~, the completion value of the |WithStatement| is *undefined*.
+
: In ECMAScript 2015, the completion value of a |SwitchStatement| is never the value ~empty~. If the |CaseBlock| part of a |SwitchStatement| produces a completion whose value is ~empty~, the completion value of the |SwitchStatement| is *undefined*.
+
: In ECMAScript 2015, it is an early error for a |Catch| clause to contain a `var` declaration for the same |Identifier| that appears as the |Catch| clause parameter. In previous editions, such a variable declaration would be instantiated in the enclosing variable environment but the declaration's |Initializer| value would be assigned to the |Catch| parameter.
+
, : In ECMAScript 2015, a runtime *SyntaxError* is thrown if a |Catch| clause evaluates a non-strict direct `eval` whose eval code includes a `var` or `FunctionDeclaration` declaration that binds the same |Identifier| that appears as the |Catch| clause parameter.
+
: In ECMAScript 2015, the completion value of a |TryStatement| is never the value ~empty~. If the |Block| part of a |TryStatement| evaluates to a normal completion whose value is ~empty~, the completion value of the |TryStatement| is *undefined*. If the |Block| part of a |TryStatement| evaluates to a throw completion and it has a |Catch| part that evaluates to a normal completion whose value is ~empty~, the completion value of the |TryStatement| is *undefined* if there is no |Finally| clause or if its |Finally| clause evalulates to an ~empty~ normal completion.
+
In ECMAScript 2015, the function objects that are created as the values of the [[Get]] or [[Set]] attribute of accessor properties in an |ObjectLiteral| are not constructor functions and they do not have a `prototype` own property. In the previous edition, they were constructors and had a `prototype` property.
+
: In ECMAScript 2015, if the argument to `Object.freeze` is not an object it is treated as if it was a non-extensible ordinary object with no own properties. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.getOwnPropertyDescriptor` is not an object an attempt is made to coerce the argument using ToObject. If the coercion is successful the result is used in place of the original argument value. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.getOwnPropertyNames` is not an object an attempt is made to coerce the argument using ToObject. If the coercion is successful the result is used in place of the original argument value. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.getPrototypeOf` is not an object an attempt is made to coerce the argument using ToObject. If the coercion is successful the result is used in place of the original argument value. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.isExtensible` is not an object it is treated as if it was a non-extensible ordinary object with no own properties. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.isFrozen` is not an object it is treated as if it was a non-extensible ordinary object with no own properties. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.isSealed` is not an object it is treated as if it was a non-extensible ordinary object with no own properties. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.keys` is not an object an attempt is made to coerce the argument using ToObject. If the coercion is successful the result is used in place of the original argument value. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.preventExtensions` is not an object it is treated as if it was a non-extensible ordinary object with no own properties. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, if the argument to `Object.seal` is not an object it is treated as if it was a non-extensible ordinary object with no own properties. In the previous edition, a non-object argument always causes a *TypeError* to be thrown.
+
: In ECMAScript 2015, the [[Prototype]] internal slot of a bound function is set to the [[GetPrototypeOf]] value of its target function. In the previous edition, [[Prototype]] was always set to %FunctionPrototype%.
+
: In ECMAScript 2015, the `length` property of function instances is configurable. In previous editions it was non-configurable.
+
: In ECMAScript 2015, the Boolean prototype object is not a Boolean instance. In previous editions it was a Boolean instance whose Boolean value was *false*.
+
: In ECMAScript 2015, the [[Prototype]] internal slot of a _NativeError_ constructor is the Error constructor. In previous editions it was the Function prototype object.
+
In ECMAScript 2015, the Number prototype object is not a Number instance. In previous editions it was a Number instance whose number value was +0.
+
In ECMAScript 2015, the Date prototype object is not a Date instance. In previous editions it was a Date instance whose TimeValue was NaN.
+
In ECMAScript 2015, the `String.prototype.localeCompare` function must treat Strings that are canonically equivalent according to the Unicode standard as being identical. In previous editions implementations were permitted to ignore canonical equivalence and could instead use a bit-wise comparison.
+
In ECMAScript 2015, the String prototype object is not a String instance. In previous editions it was a String instance whose String value was the empty string.
+
and In ECMAScript 2015, lowercase/upper conversion processing operates on code points. In previous editions such the conversion processing was only applied to individual code units. The only affected code points are those in the Deseret block of Unicode
+
In ECMAScript 2015, the `String.prototype.trim` method is defined to recognize white space code points that may exists outside of the Unicode BMP. However, as of Unicode 7 no such code points are defined. In previous editions such code points would not have been recognized as white space.
+
In ECMAScript 2015, If the _pattern_ argument is a RegExp instance and the _flags_ argument is not *undefined*, a new RegExp instance is created just like _pattern_ except that _pattern_'s flags are replaced by the argument _flags_. In previous editions a *TypeError* exception was thrown when _pattern_ was a RegExp instance and _flags_ was not *undefined*.
+
In ECMAScript 2015, the RegExp prototype object is not a RegExp instance. In previous editions it was a RegExp instance whose pattern is the empty string.
+
In ECMAScript 2015, `source`, `global`, `ignoreCase`, and `multiline` are accessor properties defined on the RegExp prototype object. In previous editions they were data properties defined on RegExp instances
+
+
+
+
+
Bibliography
+
+
+ IEEE Std 754-2008: IEEE Standard for Floating-Point Arithmetic. Institute of Electrical and Electronic Engineers, New York (2008)
+
+