diff --git a/spec.html b/spec.html
index 9f9d9ccc20c..7f591de14b3 100644
--- a/spec.html
+++ b/spec.html
@@ -24453,7 +24453,7 @@ <h1>Forbidden Extensions</h1>
         The behaviour of built-in methods which are specified in ECMA-402, such as those named `toLocaleString`, must not be extended except as specified in ECMA-402.
       </li>
       <li>
-        The RegExp pattern grammars in <emu-xref href="#sec-patterns"></emu-xref> and <emu-xref href="#sec-regular-expressions-patterns"></emu-xref> must not be extended to recognize any of the source characters A-Z or a-z as |IdentityEscape[+U]| when the <sub>[U]</sub> grammar parameter is present.
+        The RegExp pattern grammars in <emu-xref href="#sec-patterns"></emu-xref> and <emu-xref href="#sec-regular-expressions-patterns"></emu-xref> must not be extended to recognize any of the source characters A-Z or a-z as |IdentityEscape[+UnicodeFlag]| when the <sub>[UnicodeFlag]</sub> grammar parameter is present.
       </li>
       <li>
         The Syntactic Grammar must not be extended in any manner that allows the token `:` to immediately follow source text that matches the |BindingIdentifier| nonterminal symbol.
@@ -30246,31 +30246,31 @@ <h1>Patterns</h1>
       <p>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|.</p>
       <h2>Syntax</h2>
       <emu-grammar type="definition">
-        Pattern[U, N] ::
-          Disjunction[?U, ?N]
+        Pattern[UnicodeFlag, N] ::
+          Disjunction[?UnicodeFlag, ?N]
 
-        Disjunction[U, N] ::
-          Alternative[?U, ?N]
-          Alternative[?U, ?N] `|` Disjunction[?U, ?N]
+        Disjunction[UnicodeFlag, N] ::
+          Alternative[?UnicodeFlag, ?N]
+          Alternative[?UnicodeFlag, ?N] `|` Disjunction[?UnicodeFlag, ?N]
 
-        Alternative[U, N] ::
+        Alternative[UnicodeFlag, N] ::
           [empty]
-          Alternative[?U, ?N] Term[?U, ?N]
+          Alternative[?UnicodeFlag, ?N] Term[?UnicodeFlag, ?N]
 
-        Term[U, N] ::
-          Assertion[?U, ?N]
-          Atom[?U, ?N]
-          Atom[?U, ?N] Quantifier
+        Term[UnicodeFlag, N] ::
+          Assertion[?UnicodeFlag, ?N]
+          Atom[?UnicodeFlag, ?N]
+          Atom[?UnicodeFlag, ?N] Quantifier
 
-        Assertion[U, N] ::
+        Assertion[UnicodeFlag, N] ::
           `^`
           `$`
           `\` `b`
           `\` `B`
-          `(` `?` `=` Disjunction[?U, ?N] `)`
-          `(` `?` `!` Disjunction[?U, ?N] `)`
-          `(` `?` `&lt;=` Disjunction[?U, ?N] `)`
-          `(` `?` `&lt;!` Disjunction[?U, ?N] `)`
+          `(` `?` `=` Disjunction[?UnicodeFlag, ?N] `)`
+          `(` `?` `!` Disjunction[?UnicodeFlag, ?N] `)`
+          `(` `?` `&lt;=` Disjunction[?UnicodeFlag, ?N] `)`
+          `(` `?` `&lt;!` Disjunction[?UnicodeFlag, ?N] `)`
 
         Quantifier ::
           QuantifierPrefix
@@ -30284,13 +30284,13 @@ <h2>Syntax</h2>
           `{` DecimalDigits[~Sep] `,` `}`
           `{` DecimalDigits[~Sep] `,` DecimalDigits[~Sep] `}`
 
-        Atom[U, N] ::
+        Atom[UnicodeFlag, N] ::
           PatternCharacter
           `.`
-          `\` AtomEscape[?U, ?N]
-          CharacterClass[?U]
-          `(` GroupSpecifier[?U] Disjunction[?U, ?N] `)`
-          `(` `?` `:` Disjunction[?U, ?N] `)`
+          `\` AtomEscape[?UnicodeFlag, ?N]
+          CharacterClass[?UnicodeFlag]
+          `(` GroupSpecifier[?UnicodeFlag] Disjunction[?UnicodeFlag, ?N] `)`
+          `(` `?` `:` Disjunction[?UnicodeFlag, ?N] `)`
 
         SyntaxCharacter :: one of
           `^` `$` `\` `.` `*` `+` `?` `(` `)` `[` `]` `{` `}` `|`
@@ -30298,19 +30298,19 @@ <h2>Syntax</h2>
         PatternCharacter ::
           SourceCharacter but not SyntaxCharacter
 
-        AtomEscape[U, N] ::
+        AtomEscape[UnicodeFlag, N] ::
           DecimalEscape
-          CharacterClassEscape[?U]
-          CharacterEscape[?U]
-          [+N] `k` GroupName[?U]
+          CharacterClassEscape[?UnicodeFlag]
+          CharacterEscape[?UnicodeFlag]
+          [+N] `k` GroupName[?UnicodeFlag]
 
-        CharacterEscape[U] ::
+        CharacterEscape[UnicodeFlag] ::
           ControlEscape
           `c` ControlLetter
           `0` [lookahead &lt;! DecimalDigit]
           HexEscapeSequence
-          RegExpUnicodeEscapeSequence[?U]
-          IdentityEscape[?U]
+          RegExpUnicodeEscapeSequence[?UnicodeFlag]
+          IdentityEscape[?UnicodeFlag]
 
         ControlEscape :: one of
           `f` `n` `r` `t` `v`
@@ -30319,39 +30319,39 @@ <h2>Syntax</h2>
           `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`
 
-        GroupSpecifier[U] ::
+        GroupSpecifier[UnicodeFlag] ::
           [empty]
-          `?` GroupName[?U]
+          `?` GroupName[?UnicodeFlag]
 
-        GroupName[U] ::
-          `&lt;` RegExpIdentifierName[?U] `&gt;`
+        GroupName[UnicodeFlag] ::
+          `&lt;` RegExpIdentifierName[?UnicodeFlag] `&gt;`
 
-        RegExpIdentifierName[U] ::
-          RegExpIdentifierStart[?U]
-          RegExpIdentifierName[?U] RegExpIdentifierPart[?U]
+        RegExpIdentifierName[UnicodeFlag] ::
+          RegExpIdentifierStart[?UnicodeFlag]
+          RegExpIdentifierName[?UnicodeFlag] RegExpIdentifierPart[?UnicodeFlag]
 
-        RegExpIdentifierStart[U] ::
+        RegExpIdentifierStart[UnicodeFlag] ::
           UnicodeIDStart
           `$`
           `_`
-          `\` RegExpUnicodeEscapeSequence[+U]
-          [~U] UnicodeLeadSurrogate UnicodeTrailSurrogate
+          `\` RegExpUnicodeEscapeSequence[+UnicodeFlag]
+          [~UnicodeFlag] UnicodeLeadSurrogate UnicodeTrailSurrogate
 
-        RegExpIdentifierPart[U] ::
+        RegExpIdentifierPart[UnicodeFlag] ::
           UnicodeIDContinue
           `$`
-          `\` RegExpUnicodeEscapeSequence[+U]
-          [~U] UnicodeLeadSurrogate UnicodeTrailSurrogate
+          `\` RegExpUnicodeEscapeSequence[+UnicodeFlag]
+          [~UnicodeFlag] UnicodeLeadSurrogate UnicodeTrailSurrogate
           &lt;ZWNJ&gt;
           &lt;ZWJ&gt;
 
-        RegExpUnicodeEscapeSequence[U] ::
-          [+U] `u` HexLeadSurrogate `\u` HexTrailSurrogate
-          [+U] `u` HexLeadSurrogate
-          [+U] `u` HexTrailSurrogate
-          [+U] `u` HexNonSurrogate
-          [~U] `u` Hex4Digits
-          [+U] `u{` CodePoint `}`
+        RegExpUnicodeEscapeSequence[UnicodeFlag] ::
+          [+UnicodeFlag] `u` HexLeadSurrogate `\u` HexTrailSurrogate
+          [+UnicodeFlag] `u` HexLeadSurrogate
+          [+UnicodeFlag] `u` HexTrailSurrogate
+          [+UnicodeFlag] `u` HexNonSurrogate
+          [~UnicodeFlag] `u` Hex4Digits
+          [+UnicodeFlag] `u{` CodePoint `}`
 
         UnicodeLeadSurrogate ::
           &gt; any Unicode code point in the inclusive range 0xD800 to 0xDBFF
@@ -30370,23 +30370,23 @@ <h2>Syntax</h2>
         HexNonSurrogate ::
           Hex4Digits [> but only if the MV of |Hex4Digits| is not in the inclusive range 0xD800 to 0xDFFF]
 
-        IdentityEscape[U] ::
-          [+U] SyntaxCharacter
-          [+U] `/`
-          [~U] SourceCharacter but not UnicodeIDContinue
+        IdentityEscape[UnicodeFlag] ::
+          [+UnicodeFlag] SyntaxCharacter
+          [+UnicodeFlag] `/`
+          [~UnicodeFlag] SourceCharacter but not UnicodeIDContinue
 
         DecimalEscape ::
           NonZeroDigit DecimalDigits[~Sep]? [lookahead &lt;! DecimalDigit]
 
-        CharacterClassEscape[U] ::
+        CharacterClassEscape[UnicodeFlag] ::
           `d`
           `D`
           `s`
           `S`
           `w`
           `W`
-          [+U] `p{` UnicodePropertyValueExpression `}`
-          [+U] `P{` UnicodePropertyValueExpression `}`
+          [+UnicodeFlag] `p{` UnicodePropertyValueExpression `}`
+          [+UnicodeFlag] `P{` UnicodePropertyValueExpression `}`
 
         UnicodePropertyValueExpression ::
           UnicodePropertyName `=` UnicodePropertyValue
@@ -30415,37 +30415,37 @@ <h2>Syntax</h2>
           ControlLetter
           `_`
 
-        CharacterClass[U] ::
-          `[` [lookahead != `^`] ClassRanges[?U] `]`
-          `[` `^` ClassRanges[?U] `]`
+        CharacterClass[UnicodeFlag] ::
+          `[` [lookahead != `^`] ClassRanges[?UnicodeFlag] `]`
+          `[` `^` ClassRanges[?UnicodeFlag] `]`
 
-        ClassRanges[U] ::
+        ClassRanges[UnicodeFlag] ::
           [empty]
-          NonemptyClassRanges[?U]
+          NonemptyClassRanges[?UnicodeFlag]
 
-        NonemptyClassRanges[U] ::
-          ClassAtom[?U]
-          ClassAtom[?U] NonemptyClassRangesNoDash[?U]
-          ClassAtom[?U] `-` ClassAtom[?U] ClassRanges[?U]
+        NonemptyClassRanges[UnicodeFlag] ::
+          ClassAtom[?UnicodeFlag]
+          ClassAtom[?UnicodeFlag] NonemptyClassRangesNoDash[?UnicodeFlag]
+          ClassAtom[?UnicodeFlag] `-` ClassAtom[?UnicodeFlag] ClassRanges[?UnicodeFlag]
 
-        NonemptyClassRangesNoDash[U] ::
-          ClassAtom[?U]
-          ClassAtomNoDash[?U] NonemptyClassRangesNoDash[?U]
-          ClassAtomNoDash[?U] `-` ClassAtom[?U] ClassRanges[?U]
+        NonemptyClassRangesNoDash[UnicodeFlag] ::
+          ClassAtom[?UnicodeFlag]
+          ClassAtomNoDash[?UnicodeFlag] NonemptyClassRangesNoDash[?UnicodeFlag]
+          ClassAtomNoDash[?UnicodeFlag] `-` ClassAtom[?UnicodeFlag] ClassRanges[?UnicodeFlag]
 
-        ClassAtom[U] ::
+        ClassAtom[UnicodeFlag] ::
           `-`
-          ClassAtomNoDash[?U]
+          ClassAtomNoDash[?UnicodeFlag]
 
-        ClassAtomNoDash[U] ::
+        ClassAtomNoDash[UnicodeFlag] ::
           SourceCharacter but not one of `\` or `]` or `-`
-          `\` ClassEscape[?U]
+          `\` ClassEscape[?UnicodeFlag]
 
-        ClassEscape[U] ::
+        ClassEscape[UnicodeFlag] ::
           `b`
-          [+U] `-`
-          CharacterClassEscape[?U]
-          CharacterEscape[?U]
+          [+UnicodeFlag] `-`
+          CharacterClassEscape[?UnicodeFlag]
+          CharacterEscape[?UnicodeFlag]
       </emu-grammar>
 
       <emu-note>
@@ -30502,25 +30502,25 @@ <h1>Static Semantics: Early Errors</h1>
             It is a Syntax Error if IsCharacterClass of |ClassAtomNoDash| is *false* and IsCharacterClass of |ClassAtom| is *false* and the CharacterValue of |ClassAtomNoDash| is larger than the CharacterValue of |ClassAtom|.
           </li>
         </ul>
-        <emu-grammar>RegExpIdentifierStart[U] :: `\` RegExpUnicodeEscapeSequence[+U]</emu-grammar>
+        <emu-grammar>RegExpIdentifierStart[UnicodeFlag] :: `\` RegExpUnicodeEscapeSequence[+UnicodeFlag]</emu-grammar>
         <ul>
           <li>
             It is a Syntax Error if the CharacterValue of |RegExpUnicodeEscapeSequence| is not the code point value of *"$"*, *"_"*, or some code point matched by the |UnicodeIDStart| lexical grammar production.
           </li>
         </ul>
-        <emu-grammar>RegExpIdentifierStart[U] :: UnicodeLeadSurrogate UnicodeTrailSurrogate</emu-grammar>
+        <emu-grammar>RegExpIdentifierStart[UnicodeFlag] :: UnicodeLeadSurrogate UnicodeTrailSurrogate</emu-grammar>
         <ul>
           <li>
             It is a Syntax Error if the result of performing UTF16SurrogatePairToCodePoint on the two code points matched by |UnicodeLeadSurrogate| and |UnicodeTrailSurrogate| respectively is not matched by the |UnicodeIDStart| lexical grammar production.
           </li>
         </ul>
-        <emu-grammar>RegExpIdentifierPart[U] :: `\` RegExpUnicodeEscapeSequence[+U]</emu-grammar>
+        <emu-grammar>RegExpIdentifierPart[UnicodeFlag] :: `\` RegExpUnicodeEscapeSequence[+UnicodeFlag]</emu-grammar>
         <ul>
           <li>
             It is a Syntax Error if the CharacterValue of |RegExpUnicodeEscapeSequence| is not the code point value of *"$"*, *"_"*, &lt;ZWNJ&gt;, &lt;ZWJ&gt;, or some code point matched by the |UnicodeIDContinue| lexical grammar production.
           </li>
         </ul>
-        <emu-grammar>RegExpIdentifierPart[U] :: UnicodeLeadSurrogate UnicodeTrailSurrogate</emu-grammar>
+        <emu-grammar>RegExpIdentifierPart[UnicodeFlag] :: UnicodeLeadSurrogate UnicodeTrailSurrogate</emu-grammar>
         <ul>
           <li>
             It is a Syntax Error if the result of performing UTF16SurrogatePairToCodePoint on the two code points matched by |UnicodeLeadSurrogate| and |UnicodeTrailSurrogate| respectively is not matched by the |UnicodeIDContinue| lexical grammar production.
@@ -30791,9 +30791,9 @@ <h1>Static Semantics: SourceText</h1>
       <emu-clause id="sec-static-semantics-capturinggroupname" oldids="sec-regexp-identifier-names-static-semantics-stringvalue" type="sdo" aoid="CapturingGroupName">
         <h1>Static Semantics: CapturingGroupName</h1>
         <emu-grammar>
-          RegExpIdentifierName[U] ::
-            RegExpIdentifierStart[?U]
-            RegExpIdentifierName[?U] RegExpIdentifierPart[?U]
+          RegExpIdentifierName[UnicodeFlag] ::
+            RegExpIdentifierStart[?UnicodeFlag]
+            RegExpIdentifierName[?UnicodeFlag] RegExpIdentifierPart[?UnicodeFlag]
         </emu-grammar>
         <emu-alg>
           1. Let _idText_ be the source text matched by |RegExpIdentifierName|.
@@ -31739,11 +31739,11 @@ <h1>Static Semantics: ParsePattern ( _patternText_, _u_ )</h1>
           <p>The abstract operation ParsePattern takes arguments _patternText_ (a sequence of Unicode code points) and _u_ (a Boolean). It performs the following steps when called:</p>
           <emu-alg>
             1. If _u_ is *true*, then
-              1. Let _parseResult_ be ParseText(_patternText_, |Pattern[+U, +N]|).
+              1. Let _parseResult_ be ParseText(_patternText_, |Pattern[+UnicodeFlag, +N]|).
             1. Else,
-              1. Let _parseResult_ be ParseText(_patternText_, |Pattern[~U, ~N]|).
+              1. Let _parseResult_ be ParseText(_patternText_, |Pattern[~UnicodeFlag, ~N]|).
               1. If _parseResult_ is a Parse Node and _parseResult_ contains a |GroupName|, then
-                1. Set _parseResult_ to ParseText(_patternText_, |Pattern[~U, +N]|).
+                1. Set _parseResult_ to ParseText(_patternText_, |Pattern[~UnicodeFlag, +N]|).
             1. Return _parseResult_.
           </emu-alg>
         </emu-clause>
@@ -31761,7 +31761,7 @@ <h1>RegExpCreate ( _P_, _F_ )</h1>
           <h1>EscapeRegExpPattern ( _P_, _F_ )</h1>
           <p>The abstract operation EscapeRegExpPattern takes arguments _P_ and _F_. It performs the following steps when called:</p>
           <emu-alg>
-            1. Let _S_ be a String in the form of a |Pattern[~U]| (|Pattern[+U]| if _F_ contains *"u"*) equivalent to _P_ interpreted as UTF-16 encoded Unicode code points (<emu-xref href="#sec-ecmascript-language-types-string-type"></emu-xref>), in which certain code points are escaped as described below. _S_ may or may not be identical to _P_; however, the Abstract Closure that would result from evaluating _S_ as a |Pattern[~U]| (|Pattern[+U]| if _F_ contains *"u"*) must behave identically to the Abstract Closure 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. Let _S_ be a String in the form of a |Pattern[~UnicodeFlag]| (|Pattern[+UnicodeFlag]| if _F_ contains *"u"*) equivalent to _P_ interpreted as UTF-16 encoded Unicode code points (<emu-xref href="#sec-ecmascript-language-types-string-type"></emu-xref>), in which certain code points are escaped as described below. _S_ may or may not be identical to _P_; however, the Abstract Closure that would result from evaluating _S_ as a |Pattern[~UnicodeFlag]| (|Pattern[+UnicodeFlag]| if _F_ contains *"u"*) must behave identically to the Abstract Closure 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-concatenation of *"/"*, _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_.
           </emu-alg>
@@ -41915,40 +41915,40 @@ <h2>Syntax</h2>
     <emu-annex id="sec-regular-expressions-patterns">
       <h1>Regular Expressions Patterns</h1>
       <p>The syntax of <emu-xref href="#sec-patterns"></emu-xref> 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.</p>
-      <p>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.</p>
+      <p>This alternative pattern grammar and semantics only changes the syntax and semantics of BMP patterns. The following grammar extensions include productions parameterized with the [UnicodeFlag] parameter. However, none of these extensions change the syntax of Unicode patterns recognized when parsing with the [UnicodeFlag] parameter present on the goal symbol.</p>
       <h2>Syntax</h2>
       <emu-grammar type="definition">
         Term[U, N] ::
-          [+U] Assertion[+U, ?N]
-          [+U] Atom[+U, ?N] Quantifier
-          [+U] Atom[+U, ?N]
-          [~U] QuantifiableAssertion[?N] Quantifier
-          [~U] Assertion[~U, ?N]
-          [~U] ExtendedAtom[?N] Quantifier
-          [~U] ExtendedAtom[?N]
+          [+UnicodeFlag] Assertion[+UnicodeFlag, ?N]
+          [+UnicodeFlag] Atom[+UnicodeFlag, ?N] Quantifier
+          [+UnicodeFlag] Atom[+UnicodeFlag, ?N]
+          [~UnicodeFlag] QuantifiableAssertion[?N] Quantifier
+          [~UnicodeFlag] Assertion[~UnicodeFlag, ?N]
+          [~UnicodeFlag] ExtendedAtom[?N] Quantifier
+          [~UnicodeFlag] ExtendedAtom[?N]
 
         Assertion[U, N] ::
           `^`
           `$`
           `\` `b`
           `\` `B`
-          [+U] `(` `?` `=` Disjunction[+U, ?N] `)`
-          [+U] `(` `?` `!` Disjunction[+U, ?N] `)`
-          [~U] QuantifiableAssertion[?N]
+          [+UnicodeFlag] `(` `?` `=` Disjunction[+UnicodeFlag, ?N] `)`
+          [+UnicodeFlag] `(` `?` `!` Disjunction[+UnicodeFlag, ?N] `)`
+          [~UnicodeFlag] QuantifiableAssertion[?N]
           `(` `?` `&lt;=` Disjunction[?U, ?N] `)`
           `(` `?` `&lt;!` Disjunction[?U, ?N] `)`
 
         QuantifiableAssertion[N] ::
-          `(` `?` `=` Disjunction[~U, ?N] `)`
-          `(` `?` `!` Disjunction[~U, ?N] `)`
+          `(` `?` `=` Disjunction[~UnicodeFlag, ?N] `)`
+          `(` `?` `!` Disjunction[~UnicodeFlag, ?N] `)`
 
         ExtendedAtom[N] ::
           `.`
-          `\` AtomEscape[~U, ?N]
+          `\` AtomEscape[~UnicodeFlag, ?N]
           `\` [lookahead == `c`]
-          CharacterClass[~U]
-          `(` Disjunction[~U, ?N] `)`
-          `(` `?` `:` Disjunction[~U, ?N] `)`
+          CharacterClass[~UnicodeFlag]
+          `(` Disjunction[~UnicodeFlag, ?N] `)`
+          `(` `?` `:` Disjunction[~UnicodeFlag, ?N] `)`
           InvalidBracedQuantifier
           ExtendedPatternCharacter
 
@@ -41961,25 +41961,25 @@ <h2>Syntax</h2>
           SourceCharacter but not one of `^` `$` `\` `.` `*` `+` `?` `(` `)` `[` `|`
 
         AtomEscape[U, N] ::
-          [+U] DecimalEscape
-          [~U] DecimalEscape [> but only if the CapturingGroupNumber of |DecimalEscape| is &le; _NcapturingParens_]
-          CharacterClassEscape[?U]
+          [+UnicodeFlag] DecimalEscape
+          [~UnicodeFlag] DecimalEscape [> but only if the CapturingGroupNumber of |DecimalEscape| is &le; _NcapturingParens_]
+          CharacterClassEscape[?UnicodeFlag]
           CharacterEscape[?U, ?N]
-          [+N] `k` GroupName[?U]
+          [+N] `k` GroupName[?UnicodeFlag]
 
         CharacterEscape[U, N] ::
           ControlEscape
           `c` ControlLetter
           `0` [lookahead &lt;! DecimalDigit]
           HexEscapeSequence
-          RegExpUnicodeEscapeSequence[?U]
-          [~U] LegacyOctalEscapeSequence
+          RegExpUnicodeEscapeSequence[?UnicodeFlag]
+          [~UnicodeFlag] LegacyOctalEscapeSequence
           IdentityEscape[?U, ?N]
 
         IdentityEscape[U, N] ::
-          [+U] SyntaxCharacter
-          [+U] `/`
-          [~U] SourceCharacterIdentityEscape[?N]
+          [+UnicodeFlag] SyntaxCharacter
+          [+UnicodeFlag] `/`
+          [~UnicodeFlag] SourceCharacterIdentityEscape[?N]
 
         SourceCharacterIdentityEscape[N] ::
           [~N] SourceCharacter but not `c`
@@ -41992,9 +41992,9 @@ <h2>Syntax</h2>
 
         ClassEscape[U, N] ::
           `b`
-          [+U] `-`
-          [~U] `c` ClassControlLetter
-          CharacterClassEscape[?U]
+          [+UnicodeFlag] `-`
+          [~UnicodeFlag] `c` ClassControlLetter
+          CharacterClassEscape[?UnicodeFlag]
           CharacterEscape[?U, ?N]
 
         ClassControlLetter ::
@@ -42002,7 +42002,7 @@ <h2>Syntax</h2>
           `_`
       </emu-grammar>
       <emu-note>
-        <p>When the same left hand sides occurs with both [+U] and [\~U] guards it is to control the disambiguation priority.</p>
+        <p>When the same left hand sides occurs with both [+UnicodeFlag] and [\~U] guards it is to control the disambiguation priority.</p>
       </emu-note>
 
       <emu-annex id="sec-patterns-static-semantics-early-errors-annexb">
@@ -42018,7 +42018,7 @@ <h1>Static Semantics: Early Errors</h1>
         <emu-grammar>NonemptyClassRanges :: ClassAtom `-` ClassAtom ClassRanges</emu-grammar>
         <ul>
           <li>
-            It is a Syntax Error if IsCharacterClass of the first |ClassAtom| is *true* or IsCharacterClass of the second |ClassAtom| is *true* <ins>and this production has a <sub>[U]</sub> parameter</ins>.
+            It is a Syntax Error if IsCharacterClass of the first |ClassAtom| is *true* or IsCharacterClass of the second |ClassAtom| is *true* <ins>and this production has a <sub>[UnicodeFlag]</sub> parameter</ins>.
           </li>
           <li>
             It is a Syntax Error if IsCharacterClass of the first |ClassAtom| is *false* and IsCharacterClass of the second |ClassAtom| is *false* and the CharacterValue of the first |ClassAtom| is larger than the CharacterValue of the second |ClassAtom|.
@@ -42027,7 +42027,7 @@ <h1>Static Semantics: Early Errors</h1>
         <emu-grammar>NonemptyClassRangesNoDash :: ClassAtomNoDash `-` ClassAtom ClassRanges</emu-grammar>
         <ul>
           <li>
-            It is a Syntax Error if IsCharacterClass of |ClassAtomNoDash| is *true* or IsCharacterClass of |ClassAtom| is *true* <ins>and this production has a <sub>[U]</sub> parameter</ins>.
+            It is a Syntax Error if IsCharacterClass of |ClassAtomNoDash| is *true* or IsCharacterClass of |ClassAtom| is *true* <ins>and this production has a <sub>[UnicodeFlag]</sub> parameter</ins>.
           </li>
           <li>
             It is a Syntax Error if IsCharacterClass of |ClassAtomNoDash| is *false* and IsCharacterClass of |ClassAtom| is *false* and the CharacterValue of |ClassAtomNoDash| is larger than the CharacterValue of |ClassAtom|.