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

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 (

6.1.4

). 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

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

This section is amended in

B.1.4.4

22.2.1.5 Static Semantics: SourceText

22.2.1.6 Static Semantics: CapturingGroupName

22.2.2 Pattern Semantics

583

NOTE 2

The descriptions below use the following aliases:

Input

is a

List

whose elements are the characters 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

[

] means the

character of

Input

, where

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

Atom

(

GroupSpecifier

Disjunction

)

Parse Nodes) in the pattern. A left-capturing parenthesis is any

((

pattern

character that is matched by the

((

terminal of the

Atom

(

GroupSpecifier

Disjunction

)

production.

DotAll

true

if the RegExp object's [[OriginalFlags]] internal slot contains

"s"

and otherwise is

false

IgnoreCase

true

if the RegExp object's [[OriginalFlags]] internal slot contains

"i"

and otherwise is

false

Multiline

true

if the RegExp object's [[OriginalFlags]] internal slot contains

"m"

and otherwise is

false

Unicode

true

if the RegExp object's [[OriginalFlags]] internal slot contains

"u"

and otherwise is

false

WordCharacters

is the mathematical set that is the union of all sixty-three characters in

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"

(letters, numbers, and

U+005F (LOW LINE) in the Unicode Basic Latin block) and all characters

for which

is not in that set but

Canonicalize

(

) is.

WordCharacters

cannot contain more than sixty-three characters unless

Unicode

and

IgnoreCase

are both

true

Furthermore, the descriptions below use the following internal data structures:

CharSet

is a mathematical set of characters. When the

Unicode

flag is

true

, “all characters” means the CharSet

containing all code point values; otherwise “all characters” means the CharSet containing all code unit values.
A

State

is an ordered pair (

endIndex

captures

) where

endIndex

is an

integer

and

captures

is a

List

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

element of

captures

is either a

List

of characters that

represents the value obtained by the

set of capturing parentheses or

undefined

if the

set of capturing

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

UTF16SurrogatePairToCodePoint

must be used in producing a

List

whose sole element is 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.

22.2.2.1 Notation

584

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.

Continuation

is an

Abstract Closure

that takes one State argument and returns a MatchResult result. The

Continuation attempts to match the remaining portion (specified by the closure's captured values) 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

Matcher

is an

Abstract 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 captured
values) 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.

The production

Pattern

Disjunction

evaluates as follows:

1. Evaluate

Disjunction

with 1 as its

direction

argument to obtain a Matcher

2. Return a new

Abstract Closure

with parameters (

str

index

) that captures

and performs the following steps

when called:

Assert

Type

(

str

) is String.

Assert

index

is a non-negative

integer

which is

≤

the length of

str

c. If

Unicode

true

, let

Input

be !

StringToCodePoints

(

str

). Otherwise, let

Input

be a

List

whose elements

are the code units that are the elements of

str

Input

will be used throughout the algorithms in

22.2.2

Each element of

Input

is considered to be a character.

d. Let

InputLength

be the number of characters contained in

Input

. This alias will be used throughout the

algorithms in

22.2.2

e. Let

listIndex

be the index into

Input

of the character that was obtained from element

index

str

f. Let

be a new Continuation with parameters (

) that captures nothing and performs the following steps

when called:

Assert

is a State.

ii. Return

g. Let

cap

be a

List

NcapturingParens

undefined

values, indexed 1 through

NcapturingParens

h. Let

be the State (

listIndex

cap

i. Return

(

NOTE

A Pattern evaluates (“compiles”) to an

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

22.2.2

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

Abstract Closure

to find a match in a String cannot throw an

exception (except for any

implementation-defined

exceptions that can occur anywhere such as

out-of-memory).

22.2.2.2 Pattern

585

With parameter

direction

The production

Disjunction

Alternative

evaluates as follows:

1. Evaluate

Alternative

with argument

direction

to obtain a Matcher

2. Return

The production

Disjunction

Alternative

Disjunction

evaluates as follows:

1. Evaluate

Alternative

with argument

direction

to obtain a Matcher

2. Evaluate

Disjunction

with argument

direction

to obtain a Matcher

3. Return a new Matcher with parameters (

) that captures

and

and performs the following steps when

called:

Assert

is a State.

Assert

is a Continuation.

c. Let

(

d. If

is not

failure

, return

e. Return

(

NOTE

With parameter

direction

The production

Alternative

[empty] evaluates as follows:

1. Return a new Matcher with parameters (

) that captures nothing and performs the following steps when

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,

returns the result

"a"

and not

"ab"

. Moreover,

returns the array

and not

The order in which the two alternatives are tried is independent of the value of

direction

/a|ab/.exec(

"abc"

)

/((a)|(ab))((c)|(bc))/.exec(

"abc"

)

[

"abc"

"a"

undefined

"bc"

undefined

"bc"

]

[

"abc"

"ab"

undefined

"ab"

"c"

undefined

]

22.2.2.3 Disjunction

22.2.2.4 Alternative

586

called:

Assert

is a State.

Assert

is a Continuation.

c. Return

(

The production

Alternative

Term

evaluates as follows:

1. Evaluate

Alternative

with argument

direction

to obtain a Matcher

2. Evaluate

Term

with argument

direction

to obtain a Matcher

3. If

direction

= 1, then

a. Return a new Matcher with parameters (

) that captures

and

and performs the following steps

when called:

Assert

is a State.

ii.

Assert

is a Continuation.

iii. Let

be a new Continuation with parameters (

) that captures

and

and performs the

following steps when called:

Assert

is a State.

2. Return

(

iv. Return

(

4. Else,

Assert

direction

is -1.

b. Return a new Matcher with parameters (

) that captures

and

and performs the following steps

when called:

Assert

is a State.

ii.

Assert

is a Continuation.

iii. Let

be a new Continuation with parameters (

) that captures

and

and performs the

following steps when called:

Assert

is a State.

2. Return

(

iv. Return

(

NOTE

With parameter

direction

The production

Term

Assertion

evaluates as follows:

1. Return the Matcher that is the result of evaluating

Assertion

NOTE

The production

Term

Atom

evaluates as follows:

Consecutive

Term

s try to simultaneously match consecutive portions of

Input

. When

direction

= 1,

, 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

. When

direction

= -1, the evaluation order of

Alternative

and

Term

are reversed.

The resulting Matcher is independent of

direction

22.2.2.5 Term

587

1. Return the Matcher that is the result of evaluating

Atom

with argument

direction

The production

Term

Atom

Quantifier

evaluates as follows:

1. Evaluate

Atom

with argument

direction

to obtain a Matcher

2. Evaluate

Quantifier

to obtain the three results: a non-negative

integer

min

, a non-negative

integer

(or +

∞

)

max

and Boolean

greedy

Assert

min

≤

max

4. Let

parenIndex

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

of this

Term

. This is the total number of

Atom

(

GroupSpecifier

Disjunction

)

Parse Nodes prior to or

enclosing this

Term

5. Let

parenCount

be the number of left-capturing parentheses in

Atom

. This is the total number of

Atom

(

GroupSpecifier

Disjunction

)

Parse Nodes enclosed by

Atom

6. Return a new Matcher with parameters (

) that captures

min

max

greedy

parenIndex

, and

parenCount

and

performs the following steps when called:

Assert

is a State.

Assert

is a Continuation.

c. Return !

RepeatMatcher

(

min

max

greedy

parenIndex

parenCount

The abstract operation RepeatMatcher takes arguments

(a Matcher),

min

(a non-negative

integer

max

(a non-

negative

integer

or +

∞

greedy

(a Boolean),

(a State),

(a Continuation),

parenIndex

(a non-negative

integer

), and

parenCount

(a non-negative

integer

). It performs the following steps when called:

1. If

max

= 0, return

(

2. Let

be a new Continuation with parameters (

) that captures

min

max

greedy

parenIndex

, and

parenCount

and performs the following steps when called:

Assert

is a State.

b. If

min

= 0 and

endIndex

, return

failure

c. If

min

= 0, let

min2

be 0; otherwise let

min2

min

- 1.

d. If

max

is +

∞

, let

max2

be +

∞

; otherwise let

max2

max

- 1.

e. Return !

RepeatMatcher

(

min2

max2

greedy

parenIndex

parenCount

3. Let

cap

be a copy of

captures

List

4. For each

integer

such that

parenIndex

and

≤

parenIndex

parenCount

, set

cap

[

] to

undefined

5. Let

endIndex

6. Let

be the State (

cap

7. If

min

≠

0, return

(

8. If

greedy

false

, then

a. Let

(

b. If

is not

failure

, return

c. Return

(

9. Let

(

10. If

is not

failure

, return

11. Return

(

22.2.2.5.1 RepeatMatcher (

min

max

greedy

parenIndex

parenCount

)

588

Content .. 50 51 52 53 ..