ECMA-262 (12th Edition) ECMAScript 2021 Language Specification - page 53

evaluates as follows:

1. Return a new Matcher with parameters (

) that captures nothing and performs the following steps when

called:

is a State.

is a Continuation.

c. Let

endIndex

d. If

= 0, or if

Multiline

true

and the character

Input

[

- 1] is one of

LineTerminator

, then

i. Return

(

e. Return

failure

NOTE

The production

of the RepeatMatcher clears

evaluates as follows:

Step

's captures each time

is repeated. We can see its

behaviour in the regular expression

which returns the array

and not

because each iteration of the outermost

clears all captured Strings contained in the quantified

, which in this case includes capture Strings numbered 2, 3, 4, and 5.

/(z)((a+)?(b+)?(c))*/.exec(

"zaacbbbcac"

)

[

"zaacbbbcac"

"z"

"ac"

"a"

undefined

"c"

]

[

"zaacbbbcac"

"z"

"ac"

"a"

"bbb"

"c"

]

Step

2.b

of the RepeatMatcher states that once the minimum number of repetitions has been

satisfied, any more expansions of

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:

or the slightly more complicated:

which returns the array

/(a*)*/.exec(

"b"

)

/(a*)b\

+/.exec(

"baaaac"

)

[

"b"

]

Even when the

flag is used with a pattern,

always matches only at the beginning of

Input

, or

(if

Multiline

true

) at the beginning of a line.

22.2.2.6 Assertion

590

1. Return a new Matcher with parameters (

) that captures nothing and performs the following steps when

called:

is a State.

is a Continuation.

c. Let

endIndex

d. If

InputLength

, or if

Multiline

true

and the character

Input

[

] is one of

LineTerminator

, then

i. Return

(

e. Return

failure

The production

evaluates as follows:

1. Return a new Matcher with parameters (

) that captures nothing and performs the following steps when

called:

is a State.

is a Continuation.

c. Let

endIndex

d. Let

(

- 1).

e. Let

(

f. If

true

and

false

, or if

false

and

true

, return

(

g. Return

failure

The production

evaluates as follows:

1. Return a new Matcher with parameters (

) that captures nothing and performs the following steps when

called:

is a State.

is a Continuation.

c. Let

endIndex

d. Let

(

- 1).

e. Let

(

f. If

true

and

true

, or if

false

and

false

, return

(

g. Return

failure

The production

(

)

evaluates as follows:

with 1 as its

direction

argument to obtain a Matcher

2. Return a new Matcher with parameters (

) that captures

and performs the following steps when called:

is a State.

is a Continuation.

c. Let

be a new Continuation with parameters (

) that captures nothing and performs the following steps

when called:

is a State.

ii. Return

d. Let

(

e. If

failure

, return

failure

f. Let

's State.

g. Let

cap

captures

h. Let

endIndex

i. Let

be the State (

cap

j. Return

(

591

The production

(

)

evaluates as follows:

with 1 as its

direction

argument to obtain a Matcher

2. Return a new Matcher with parameters (

) that captures

and performs the following steps when called:

is a State.

is a Continuation.

c. Let

be a new Continuation with parameters (

) that captures nothing and performs the following steps

when called:

is a State.

ii. Return

d. Let

(

e. If

is not

failure

, return

failure

f. Return

(

The production

(

)

evaluates as follows:

with -1 as its

direction

argument to obtain a Matcher

2. Return a new Matcher with parameters (

) that captures

and performs the following steps when called:

is a State.

is a Continuation.

c. Let

be a new Continuation with parameters (

) that captures nothing and performs the following steps

when called:

is a State.

ii. Return

d. Let

(

e. If

failure

, return

failure

f. Let

's State.

g. Let

cap

captures

h. Let

endIndex

i. Let

be the State (

cap

j. Return

(

The production

(

)

evaluates as follows:

with -1 as its

direction

argument to obtain a Matcher

2. Return a new Matcher with parameters (

) that captures

and performs the following steps when called:

is a State.

is a Continuation.

c. Let

be a new Continuation with parameters (

) that captures nothing and performs the following steps

when called:

is a State.

ii. Return

d. Let

(

e. If

is not

failure

, return

failure

f. Return

(

The abstract operation IsWordChar takes argument

(an

). It performs the following steps when called:

22.2.2.6.1 IsWordChar (

)

592

1. If

= -1 or

InputLength

, return

false

2. Let

be the character

Input

[

3. If

is in

WordCharacters

, return

true

4. Return

false

The production

Quantifier

evaluates as follows:

to obtain the two results: an

min

and an

(or +

∞

)

max

2. Return the three results

min

max

, and

true

The production

Quantifier

evaluates as follows:

to obtain the two results: an

min

and an

(or +

∞

)

max

2. Return the three results

min

max

, and

false

The production

evaluates as follows:

1. Return the two results 0 and +

∞

The production

evaluates as follows:

1. Return the two results 1 and +

∞

The production

evaluates as follows:

1. Return the two results 0 and 1.

The production

{

}

evaluates as follows:

1. Let

2. Return the two results

and

The production

{

}

evaluates as follows:

1. Let

be the MV of

2. Return the two results

and +

∞

The production

{

}

evaluates as follows:

1. Let

be the MV of the first

2. Let

be the MV of the second

3. Return the two results

and

With parameter

direction

The production

PatternCharacter

evaluates as follows:

1. Let

be the character matched by

PatternCharacter

2. Let

be a one-element CharSet containing the character

3. Return !

CharacterSetMatcher

(

false

direction

22.2.2.7 Quantifier

22.2.2.8 Atom

593

The production

evaluates as follows:

1. Let

be the CharSet of all characters.

2. If

DotAll

is not

true

, then

a. Remove from

all characters corresponding to a code point on the right-hand side of the

LineTerminator

production.

3. Return !

CharacterSetMatcher

(

false

direction

The production

AtomEscape

evaluates as follows:

1. Return the Matcher that is the result of evaluating

AtomEscape

with argument

direction

The production

CharacterClass

evaluates as follows:

CharacterClass

to obtain a CharSet

and a Boolean

invert

2. Return !

CharacterSetMatcher

(

invert

direction

The production

(

GroupSpecifier

)

evaluates as follows:

with argument

direction

to obtain a Matcher

2. Let

parenIndex

be the number of left-capturing parentheses in the entire regular expression that occur to the left

of this

. This is the total number of

(

GroupSpecifier

)

Parse Nodes prior to or

enclosing this

3. Return a new Matcher with parameters (

) that captures

direction

, and

parenIndex

and performs the

following steps when called:

is a State.

is a Continuation.

c. Let

be a new Continuation with parameters (

) that captures

direction

, and

parenIndex

and

performs the following steps when called:

is a State.

ii. Let

cap

be a copy of

captures

iii. Let

endIndex

iv. Let

endIndex

v. If

direction

= 1, then

≤

2. Let

be a

whose elements are the characters of

Input

at indices

(inclusive) through

(exclusive).

vi. Else,

direction

is -1.

≤

3. Let

be a

whose elements are the characters of

Input

at indices

(inclusive) through

(exclusive).

vii. Set

cap

[

parenIndex

+ 1] to

viii. Let

be the State (

cap

ix. Return

(

d. Return

(

The production

(

)

evaluates as follows:

1. Return the Matcher that is the result of evaluating

with argument

direction

594

The abstract operation CharacterSetMatcher takes arguments

(a CharSet),

invert

(a Boolean), and

direction

(1 or -1). It

performs the following steps when called:

1. Return a new Matcher with parameters (

) that captures

invert

, and

direction

and performs the following

steps when called:

is a State.

is a Continuation.

c. Let

endIndex

d. Let

direction

e. If

< 0 or

InputLength

, return

failure

f. Let

index

min

g. Let

be the character

Input

[

index

h. Let

Canonicalize

i. If there exists a member

such that

Canonicalize

(

) is

, let

found

true

. Otherwise, let

found

false

j. If

invert

false

and

found

false

, return

failure

k. If

invert

true

and

found

true

, return

failure

l. Let

cap

captures

m. Let

be the State (

cap

n. Return

(

The abstract operation Canonicalize takes argument

(a character). It performs the following steps when called:

1. If

Unicode

true

and

IgnoreCase

true

, then

a. If the file CaseFolding.txt of the Unicode Character Database provides a simple or common case folding

mapping for

, return the result of applying that mapping to

b. Return

2. If

IgnoreCase

false

, return

is a UTF-16 code unit.

4. Let

be the code point whose numeric value is that of

5. Let

be the result of toUppercase(«

»), according to the Unicode Default Case Conversion algorithm.

6. Let

uStr

be !

CodePointsToString

7. If

uStr

does not consist of a single code unit, return

8. Let

uStr

's single code unit element.

9. If the numeric value of

≥

128 and the numeric value of

< 128, return

10. Return

NOTE 1

Parentheses of the form

((

))

serve both to group the components of the

pattern together and to save the result of the match. The result can be used either in a
backreference (

followed by a non-zero decimal number), referenced in a replace String, or

returned as part of an array from the regular expression matching

Abstract Closure

. To inhibit the

capturing behaviour of parentheses, use the form

(?:

))

instead.

22.2.2.8.1 CharacterSetMatcher (

invert

direction

)

22.2.2.8.2 Canonicalize (

)

595

NOTE 2

NOTE 3

The form

(?=

))

specifies a zero-width positive lookahead. In order for it to succeed,

the pattern inside

must match at the current position, but the current position is not

advanced before matching the sequel. If

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

contains capturing parentheses and the sequel of the pattern contains

backreferences to those captures.

For example,

matches the empty String immediately after the first

and therefore returns the array:

To illustrate the lack of backtracking into the lookahead, consider:

This expression returns

and not:

/(?=(a+))/.exec(

"baaabac"

)

[

"aaa"

]

/(?=(a+))a*b\

/.exec(

"baaabac"

)

[

"aba"

"a"

]

[

"aaaba"

"a"

]

The form

(?!

))

specifies a zero-width negative lookahead. In order for it to succeed,

the pattern inside

must fail to match at the current position. The current position is

not advanced before matching the sequel.

can contain capturing parentheses, but

backreferences to them only make sense from within

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,

looks for an

not immediately followed by some positive number n of

's, a

, another n

(specified by the first

) and a

. The second

is outside the negative lookahead, so it

matches against

undefined

and therefore always succeeds. The whole expression returns the

array:

/(.*?)a(?!(a+)b\2c)\

(.*)/.exec(

"baaabaac"

)

[

"baaabaac"

"ba"

undefined

"abaac"

]

596

NOTE 4

The abstract operation UnicodeMatchProperty takes argument

of Unicode code points). It performs the

following steps when called:

is a

of Unicode code points that is identical to a

of Unicode code points that is a Unicode

property name or property alias listed in the “Property name and aliases” column of

Table 56

Table 57

2. Let

be the canonical property name of

as given in the “Canonical property name” column of the

corresponding row.

3. Return the

of Unicode code points of

Implementations must support the Unicode property names and aliases listed in

Table 56

and

Table 57

. To ensure

interoperability, implementations must not support any other property names or aliases.

NOTE 1

NOTE 2

Table 56: Non-binary Unicode property aliases and their canonical property names

Property name

and aliases

Canonical

property name

General_Category

Script

Script_Extensions

scx

Table 57: Binary Unicode property aliases and their canonical property names

Property name

and aliases

Canonical

property name

ASCII

ASCII_Hex_Digit

AHex

Alphabetic

In case-insignificant matches when

Unicode

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

. It may however map a code point outside the Basic Latin range to a character

within, for example,

ſſ

(U+017F) to

. Such characters are not mapped if

Unicode

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

For example,

Script_Extensions

property name

) and

scx

(property alias) are valid, but

script_extensions

Scx

aren't.

The listed properties form a superset of what

UTS18 RL1.2

requires.

22.2.2.8.3 UnicodeMatchProperty (

)

597

Alpha

Any

Assigned

Bidi_Control

Bidi_C

Bidi_Mirrored

Bidi_M

Case_Ignorable

Cased

Changes_When_Casefolded

CWCF

Changes_When_Casemapped

CWCM

Changes_When_Lowercased

CWL

Changes_When_NFKC_Casefolded

CWKCF

Changes_When_Titlecased

CWT

Changes_When_Uppercased

CWU

Dash

Default_Ignorable_Code_Point

Deprecated

Dep

Diacritic

Dia

Emoji

Emoji_Component

EComp

Emoji_Modifier

EMod

Emoji_Modifier_Base

EBase

598

(

, [[SetData]]).

3. Let

entries

be the

.[[SetData]].

4. For each element

entries

, do

a. If

is not

empty

and

SameValueZero

(

value

) is

true

, then

i. Return

5. If

value

-0

𝔽

, set

value

𝔽

6. Append

value

as the last element of

entries

7. Return

The following steps are taken:

1. Let

be the

this

value.

(

, [[SetData]]).

3. Let

entries

be the

.[[SetData]].

4. For each element

entries

, do

a. Replace the element of

entries

whose value is

with an element whose value is

empty

5. Return

undefined

NOTE

The initial value of

Set.prototype.constructor

%Set%

The following steps are taken:

1. Let

be the

this

value.

(

, [[SetData]]).

3. Let

entries

be the

.[[SetData]].

4. For each element

entries

, do

a. If

is not

empty

and

SameValueZero

(

value

) is

true

, then

i. Replace the element of

entries

whose value is

with an element whose value is

empty

ii. Return

true

5. Return

false

NOTE

The following steps are taken:

The existing [[SetData]]

is preserved because there may be existing Set Iterator objects that

are suspended midway through iterating over that

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.

24.2.3.2 Set.prototype.clear ( )

24.2.3.3 Set.prototype.constructor

24.2.3.4 Set.prototype.delete (

value

)

24.2.3.5 Set.prototype.entries ( )

698

1. Let

be the

this

value.

2. Return ?

CreateSetIterator

(

key+value

NOTE

When the

forEach

method is called with one or two arguments, the following steps are taken:

1. Let

be the

this

value.

(

, [[SetData]]).

3. If

IsCallable

callbackfn

) is

false

, throw a

TypeError

exception.

4. Let

entries

be the

.[[SetData]].

5. For each element

entries

, do

a. If

is not

empty

, then

i. Perform ?

Call

(

callbackfn

thisArg

, «

»).

6. Return

undefined

NOTE

The following steps are taken:

1. Let

be the

this

value.

For iteration purposes, a Set appears similar to a Map where each entry has the same value for its
key and value.

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.

24.2.3.6 Set.prototype.forEach (

callbackfn

[ ,

thisArg

] )

24.2.3.7 Set.prototype.has (

value

)

699

(

, [[SetData]]).

3. Let

entries

be the

.[[SetData]].

4. For each element

entries

, do

a. If

is not

empty

and

SameValueZero

(

value

) is

true

, return

true

5. Return

false

The initial value of the

"keys"

property is the same

function object

as the initial value of the

"values"

property.

NOTE

Set.prototype.size

is an

accessor property

whose set accessor function is

undefined

. Its get accessor function

performs the following steps:

1. Let

be the

this

value.

(

, [[SetData]]).

3. Let

entries

be the

as the initial value of the

.[[SetData]].

4. Let

count

be 0.

5. For each element

entries

, do

a. If

is not

empty

, set

count

+ 1.

6. Return

count

The following steps are taken:

1. Let

be the

this

value.

2. Return ?

CreateSetIterator

(

value

The initial value of the

@@iterator

property is the same

function object

"values"

property.

The initial value of the

@@toStringTag

property is the String value

"Set"

This property has the attributes { [[Writable]]:

false

, [[Enumerable]]:

false

, [[Configurable]]:

true

Set instances are ordinary objects that inherit properties from the Set prototype. Set instances also have a [[SetData]]
internal slot.

For iteration purposes, a Set appears similar to a Map where each entry has the same value for its
key and value.

24.2.3.8 Set.prototype.keys ( )

24.2.3.9 get Set.prototype.size

24.2.3.10 Set.prototype.values ( )

24.2.3.11 Set.prototype [ @@iterator ] ( )

24.2.3.12 Set.prototype [ @@toStringTag ]

24.2.4 Properties of Set Instances

700

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

for Set Iterator objects. Instead, set iterator objects are

created by calling certain methods of Set instance objects.

The abstract operation CreateSetIterator takes arguments

set

and

kind

. This operation is used to create iterator objects

for Set methods that return such iterators. It performs the following steps when called:

kind

key+value

value

(

set

, [[SetData]]).

3. Let

closure

be a new

Abstract Closure

with no parameters that captures

set

and

kind

and performs the following

steps when called:

a. Let

index

be 0.

b. Let

entries

be the

set

.[[SetData]].

c. Let

numEntries

be the number of elements of

entries

d. Repeat, while

index

numEntries

i. Let

entries

[

index

ii. Set

index

+ 1.

iii. If

is not

empty

, then

1. If

kind

key+value

, then

a. Perform ?

Yield

CreateArrayFromList

(«

»)).

2. Else,

abstract operation was paused by

kind

value

b. Perform ?

Yield

(

3. NOTE: the number of elements in

entries

may have changed while execution of this

Yield

4. Set

numEntries

to the number of elements of

entries

e. Return

undefined

4. Return !

CreateIteratorFromClosure

(

closure

"%SetIteratorPrototype%"

%SetIteratorPrototype%

The

%SetIteratorPrototype%

object:

has properties that are inherited by all Set Iterator Objects.
is an

ordinary object

has a [[Prototype]] internal slot whose value is

%IteratorPrototype%

has the following properties:

1. Return ?

GeneratorResume

(

this

value,

empty

"%SetIteratorPrototype%"

The initial value of the

@@toStringTag

property is the String value

"Set Iterator"

24.2.5 Set Iterator Objects

24.2.5.1 CreateSetIterator (

set

kind

)

24.2.5.2 The %SetIteratorPrototype% Object

24.2.5.2.1 %SetIteratorPrototype%.next ( )

24.2.5.2.2 %SetIteratorPrototype% [ @@toStringTag ]

701

This property has the attributes { [[Writable]]:

false

, [[Enumerable]]:

false

, [[Configurable]]:

true

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. In certain conditions, objects which are not

live

are removed as WeakMap keys, as described in

9.9.3

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.

NOTE

The WeakMap

%WeakMap%

is the initial value of the

"WeakMap"

property of the

global object

creates and initializes a new WeakMap object when called as a

http://doi.acm.org/10.1145/263698.263733

is not intended to be called as a function and will throw an exception when called in that manner.
is designed to be subclassable. It may be used as the value in an

extends

clause of a class definition. Subclass

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,

Alexandra Barros, Roberto Ierusalimschy, Eliminating Cycles in Weak Tables. Journal of
Universal Computer Science - J.UCS, vol. 14, no. 21, pp. 3481-3497, 2008,

http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak

24.3 WeakMap Objects

24.3.1 The WeakMap Constructor

702

constructors that intend to inherit the specified WeakMap behaviour must include a

super

call to the

WeakMap