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

evaluates as follows:

1. Return the CharSet that is the result of evaluating

The production

SourceCharacter

but not one of

]

evaluates as follows:

1. Return the CharSet containing the character matched by

SourceCharacter

The production

evaluates as follows:

1. Return the CharSet that is the result of evaluating

The

productions evaluate as follows:

CharacterEscape

1. Let

be the

CharacterValue

of this

2. Let

be the character whose character value is

3. Return the CharSet containing the single character

CharacterClassEscape

1. Return the CharSet that is the result of evaluating

CharacterClassEscape

NOTE

The RegExp

creates and initializes a new RegExp object when called as a function rather than as a

%RegExp%

is the initial value of the

"RegExp"

property of the

global object

. Thus the

function call

RegExp(…)

is equivalent to the object creation expression

new RegExp(…)

with the same

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

to create and initialize subclass instances with the necessary internal slots.

ClassAtom

can use any of the escape sequences that are allowed in the rest of the regular

expression except for

, and backreferences. Inside a

CharacterClass

means the

backspace character, while

and backreferences raise errors. Using a backreference inside a

ClassAtom

causes an error.

22.2.2.18 ClassAtomNoDash

22.2.2.19 ClassEscape

22.2.3 The RegExp Constructor

617

The following steps are taken:

1. Let

patternIsRegExp

IsRegExp

pattern

2. If NewTarget is

undefined

, then

a. Let

newTarget

be the

active function object

b. If

patternIsRegExp

true

and

flags

undefined

, then

i. Let

patternConstructor

Get

pattern

"constructor"

ii. If

SameValue

newTarget

patternConstructor

) is

true

, return

pattern

3. Else, let

newTarget

be NewTarget.

4. If

Type

(

pattern

) is Object and

pattern

has a [[RegExpMatcher]] internal slot, then

a. Let

pattern

.[[OriginalSource]].

b. If

flags

undefined

, let

pattern

.[[OriginalFlags]].

c. Else, let

flags

5. Else if

patternIsRegExp

true

, then

a. Let

Get

pattern

"source"

b. If

flags

undefined

, then

i. Let

Get

pattern

"flags"

c. Else, let

flags

6. Else,

a. Let

pattern

b. Let

flags

7. Let

be ?

RegExpAlloc

(

newTarget

8. Return ?

RegExpInitialize

NOTE

The abstract operation RegExpAlloc takes argument

newTarget

. It performs the following steps when called:

1. Let

obj

OrdinaryCreateFromConstructor

(

newTarget

"%RegExp.prototype%"

, « [[RegExpMatcher]],

[[OriginalSource]], [[OriginalFlags]] »).

2. Perform !

DefinePropertyOrThrow

(

obj

"lastIndex"

, PropertyDescriptor { [[Writable]]:

true

, [[Enumerable]]:

false

, [[Configurable]]:

false

}).

3. Return

obj

The abstract operation RegExpInitialize takes arguments

obj

pattern

, and

flags

. It performs the following steps when

called:

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.

22.2.3.1 RegExp (

pattern

flags

)

22.2.3.2 Abstract Operations for the RegExp Constructor

22.2.3.2.1 RegExpAlloc (

newTarget

)

22.2.3.2.2 RegExpInitialize (

obj

pattern

flags

)

618

1. If

pattern

undefined

, let

be the empty String.

2. Else, let

ToString

pattern

3. If

flags

undefined

, let

be the empty String.

4. Else, let

ToString

flags

5. If

contains any code unit other than

"g"

"i"

"m"

"s"

"u"

, or

"y"

or if it contains the same code unit more than

once, throw a

SyntaxError

exception.

6. If

contains

"u"

, let

true

; else let

false

7. If

true

, then

a. Let

patternText

be !

StringToCodePoints

(

b. Let

patternCharacters

be a

whose elements are the code points of

patternText

8. Else,

a. Let

patternText

be the result of interpreting each of

's 16-bit elements as a Unicode BMP code point.

UTF-16 decoding is not applied to the elements.

b. Let

patternCharacters

be a

whose elements are the code unit elements of

9. Let

parseResult

ParsePattern

(

patternText

10. If

parseResult

is a non-empty

SyntaxError

objects, throw a

SyntaxError

exception.

11.

parseResult

for

12. Set

obj

.[[OriginalSource]] to

13. Set

obj

.[[OriginalFlags]] to

14. Set

obj

.[[RegExpMatcher]] to the

Abstract Closure

that evaluates

parseResult

by applying the semantics

provided in

22.2.2

using

patternCharacters

as the pattern's

SourceCharacter

values and

as the flag

parameters.

15. Perform ?

Set

(

obj

"lastIndex"

𝔽

true

16. Return

obj

The abstract operation ParsePattern takes arguments

patternText

(a sequence of Unicode code points) and

Boolean). It performs the following steps when called:

1. If

true

, then

a. Let

parseResult

ParseText

patternText

[+U, +N]

2. Else,

a. Let

parseResult

ParseText

patternText

[~U, ~N]

b. If

parseResult

is a

Parse Node

and

parseResult

contains a

GroupName

, then

i. Set

parseResult

ParseText

patternText

[~U, +N]

3. Return

parseResult

The abstract operation RegExpCreate takes arguments

and

. It performs the following steps when called:

1. Let

obj

(

2. Return ?

obj

The abstract operation EscapeRegExpPattern takes arguments

and

. It performs the following steps when called:

22.2.3.2.3 Static Semantics: ParsePattern (

patternText

)

22.2.3.2.4 RegExpCreate (

)

22.2.3.2.5 EscapeRegExpPattern (

)

619

1. Let

be a String in the form of a

[~U]

) must behave identically to the

[+U]

contains

"u"

) equivalent to

interpreted as UTF-

16 encoded Unicode code points (

6.1.4

), in which certain code points are escaped as described below.

may or

may not be identical to

; however, the

Abstract Closure

that would result from evaluating

(

contains

"u"

Abstract Closure

given by the constructed object's

[[RegExpMatcher]] internal slot. Multiple calls to this abstract operation using the same values for

and

must produce identical results.

2. The code points

or any

LineTerminator

occurring in the pattern shall be escaped in

as necessary to ensure

that the

string-concatenation

"/"

, and

can be parsed (in an appropriate lexical context) as a

RegularExpressionLiteral

that behaves identically to the constructed regular expression. For example, if

"/"

then

could be

"\/"

"\u002F"

, among other possibilities, but not

"/"

, because

///

followed by

would be

parsed as a

SingleLineComment

rather than a

RegularExpressionLiteral

. If

is the empty String, this specification

can be met by letting

"(?:)"

3. Return

The RegExp

whose set accessor function is

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

%Function.prototype%

has the following properties:

The initial value of

RegExp.prototype

is the

RegExp prototype object

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

false

, [[Enumerable]]:

false

, [[Configurable]]:

false

RegExp[@@species]

is an

accessor property

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]"

NOTE

The

RegExp prototype object

%RegExp.prototype%

is an

ordinary object

is not a RegExp instance and does not have a [[RegExpMatcher]] internal slot or any of the other internal slots
of RegExp instance objects.

RegExp prototype methods normally use their

this

value's

to create a derived object.

However, a subclass