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

• 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, 8²) 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.

The semantics of 21.2.1.1 is extended as follows:

ExtendedAtom :: InvalidBracedQuantifier

• It is a Syntax Error if any source text matches this rule.

NonemptyClassRanges :: ClassAtom - ClassAtom ClassRanges

• It is a Syntax Error if IsCharacterClass of the first ClassAtom is true or IsCharacterClass of the second ClassAtom is true and this production has a _[U] parameter.

NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassRanges

• It is a Syntax Error if IsCharacterClass of ClassAtomNoDash is true or IsCharacterClass of ClassAtom is true and this production has a _[U] parameter.

The semantics of 21.2.1.3 is extended as follows:

ClassAtomNoDash :: \ [lookahead = c]

1. Return false.

The semantics of 21.2.1.4 is extended as follows:

ClassAtomNoDash :: \ [lookahead = c]

1. Return the code point value of U+005C (REVERSE SOLIDUS).

ClassEscape :: c ClassControlLetter

1. Let ch be the code point matched by ClassControlLetter.
2. Let i be ch's code point value.
3. Return the remainder of dividing i by 32.

CharacterEscape :: LegacyOctalEscapeSequence

1. Evaluate the SV of the LegacyOctalEscapeSequence (see B.1.2) to obtain a code unit cu.
2. Return the numeric value of cu.

The semantics of 21.2.2 is extended as follows:

Within 21.2.2.5 reference to “Atom :: ( GroupSpecifier Disjunction ) ” are to be interpreted as meaning “Atom :: ( GroupSpecifier Disjunction ) ” or “ExtendedAtom :: ( Disjunction ) ”.

Term (21.2.2.5) includes the following additional evaluation rules:

The production Term :: QuantifiableAssertion Quantifier evaluates the same as the production Term :: Atom Quantifier but with QuantifiableAssertion substituted for Atom.

The production Term :: ExtendedAtom Quantifier evaluates the same as the production Term :: Atom Quantifier but with ExtendedAtom substituted for Atom.

The production Term :: ExtendedAtom evaluates the same as the production Term :: Atom but with ExtendedAtom substituted for Atom.

Assertion (21.2.2.6) includes the following additional evaluation rule:

The production Assertion :: QuantifiableAssertion evaluates as follows:

1. Evaluate QuantifiableAssertion to obtain a Matcher m.
2. Return m.

Assertion (21.2.2.6) evaluation rules for the Assertion :: ( ? = Disjunction ) and Assertion :: ( ? ! Disjunction ) productions are also used for the QuantifiableAssertion productions, but with QuantifiableAssertion substituted for Assertion.

Atom (21.2.2.8) evaluation rules for the Atom productions except for Atom :: PatternCharacter are also used for the ExtendedAtom productions, but with ExtendedAtom substituted for Atom. The following evaluation rules are also added:

The production ExtendedAtom :: \ [lookahead = c] evaluates as follows:

1. Let A be the CharSet containing the single character \ U+005C (REVERSE SOLIDUS).
2. Call CharacterSetMatcher(A, false) and return its Matcher result.

The production ExtendedAtom :: ExtendedPatternCharacter evaluates as follows:

1. Let ch be the character represented by ExtendedPatternCharacter.
2. Let A be a one-element CharSet containing the character ch.
3. Call CharacterSetMatcher(A, false) and return its Matcher result.

CharacterEscape (21.2.2.10) includes the following additional evaluation rule:

The production CharacterEscape :: LegacyOctalEscapeSequence evaluates as follows:

1. Let cv be the CharacterValue of this CharacterEscape.
2. Return the character whose character value is cv.

NonemptyClassRanges (21.2.2.15) modifies the following evaluation rule:

The production NonemptyClassRanges :: ClassAtom - ClassAtom ClassRanges evaluates as follows:

1. Evaluate the first ClassAtom to obtain a CharSet A.
2. Evaluate the second ClassAtom to obtain a CharSet B.
3. Evaluate ClassRanges to obtain a CharSet C.
4. Call CharacterRangeOrUnion(A, B) and let D be the resulting CharSet.
5. Return the union of CharSets D and C.

NonemptyClassRangesNoDash (21.2.2.16) modifies the following evaluation rule:

The production NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassRanges evaluates as follows:

1. Evaluate ClassAtomNoDash to obtain a CharSet A.
2. Evaluate ClassAtom to obtain a CharSet B.
3. Evaluate ClassRanges to obtain a CharSet C.
4. Call CharacterRangeOrUnion(A, B) and let D be the resulting CharSet.
5. Return the union of CharSets D and C.

ClassEscape (21.2.2.19) includes the following additional evaluation rule:

The production ClassEscape :: c ClassControlLetter evaluates as follows:

1. Let cv be the CharacterValue of this ClassEscape.
2. Let c be the character whose character value is cv.
3. Return the CharSet containing the single character c.

ClassAtomNoDash (21.2.2.18) includes the following additional evaluation rule:

The production ClassAtomNoDash :: \ [lookahead = c] evaluates as follows:

1. Return the CharSet containing the single character \ U+005C (REVERSE SOLIDUS).

Note

This production can only be reached from the sequence \c within a character class where it is not followed by an acceptable control character.

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. Set string to ? ToString(string).
2. Let length be the number of code units in string.
3. Let R be the empty string.
4. Let k be 0.
5. Repeat, while k < length,
   1. Let char be the code unit (represented as a 16-bit unsigned integer) at index k within string.
   2. If char is one of the code units in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./", then
      1. Let S be the String value containing the single code unit char.
   3. Else if char ≥ 256, then
      1. Let n be the numeric value of char.
      2. Let S be the string-concatenation of:
         • "%u"
         • the String representation of n, formatted as a four-digit uppercase hexadecimal number, padded to the left with zeroes if necessary
   4. Else char < 256,
      1. Let n be the numeric value of char.
      2. Let S be the string-concatenation of:
         • "%"
         • the String representation of n, formatted as a two-digit uppercase hexadecimal number, padded to the left with a zero if necessary
   5. Set R to the string-concatenation of the previous value of R and S.
   6. Increase k by 1.
6. Return R.

Note

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.

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. Set string to ? ToString(string).
2. Let length be the number of code units in string.
3. Let R be the empty String.
4. Let k be 0.
5. Repeat, while k ≠ length
   1. Let c be the code unit at index k within string.
   2. If c is the code unit 0x0025 (PERCENT SIGN), then
      1. If k ≤ length - 6 and the code unit at index k + 1 within string is the code unit 0x0075 (LATIN SMALL LETTER 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. Set c to 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.
         2. Increase k by 5.
      2. 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. Set c to 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.
         2. Increase k by 2.
   3. Set R to the string-concatenation of the previous value of R and c.
   4. Increase k by 1.
6. Return R.

Object.prototype.__proto__ is an accessor property with attributes { [[Enumerable]]: false, [[Configurable]]: true }. The [[Get]] and [[Set]] attributes are defined as follows:

When the __defineGetter__ method is called with arguments P and getter, the following steps are taken:

1. Let O be ? ToObject(this value).
2. If IsCallable(getter) is false, throw a TypeError exception.
3. Let desc be PropertyDescriptor { [[Get]]: getter, [[Enumerable]]: true, [[Configurable]]: true }.
4. Let key be ? ToPropertyKey(P).
5. Perform ? DefinePropertyOrThrow(O, key, desc).
6. Return undefined.

When the __defineSetter__ method is called with arguments P and setter, the following steps are taken:

1. Let O be ? ToObject(this value).
2. If IsCallable(setter) is false, throw a TypeError exception.
3. Let desc be PropertyDescriptor { [[Set]]: setter, [[Enumerable]]: true, [[Configurable]]: true }.
4. Let key be ? ToPropertyKey(P).
5. Perform ? DefinePropertyOrThrow(O, key, desc).
6. Return undefined.

When the __lookupGetter__ method is called with argument P, the following steps are taken:

1. Let O be ? ToObject(this value).
2. Let key be ? ToPropertyKey(P).
3. Repeat,
   1. Let desc be ? O.[[GetOwnProperty]](key).
   2. If desc is not undefined, then
      1. If IsAccessorDescriptor(desc) is true, return desc.[[Get]].
      2. Return undefined.
   3. Set O to ? O.[[GetPrototypeOf]]().
   4. If O is null, return undefined.

When the __lookupSetter__ method is called with argument P, the following steps are taken:

1. Let O be ? ToObject(this value).
2. Let key be ? ToPropertyKey(P).
3. Repeat,
   1. Let desc be ? O.[[GetOwnProperty]](key).
   2. If desc is not undefined, then
      1. If IsAccessorDescriptor(desc) is true, return desc.[[Set]].
      2. Return undefined.
   3. Set O to ? O.[[GetPrototypeOf]]().
   4. If O is null, return undefined.

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).
2. Let S be ? ToString(O).
3. Let intStart be ? ToInteger(start).
4. If length is undefined, let end be +∞; otherwise let end be ? ToInteger(length).
5. Let size be the number of code units in S.
6. If intStart < 0, set intStart to max(size + intStart, 0).
7. Let resultLength be min(max(end, 0), size - intStart).
8. If resultLength ≤ 0, return the empty String "".
9. Return the String value containing resultLength consecutive code units from S beginning with the code unit at index intStart.

Note

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.

When the anchor method is called with argument name, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "a", "name", name).

When the big method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "big", "", "").

When the blink method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "blink", "", "").

When the bold method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "b", "", "").

When the fixed method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "tt", "", "").

When the fontcolor method is called with argument color, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "font", "color", color).

When the fontsize method is called with argument size, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "font", "size", size).

When the italics method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "i", "", "").

When the link method is called with argument url, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "a", "href", url).

When the small method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "small", "", "").

When the strike method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "strike", "", "").

When the sub method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "sub", "", "").

When the sup method is called with no arguments, the following steps are taken:

1. Let S be the this value.
2. Return ? CreateHTML(S, "sup", "", "").

Note

The property trimStart is preferred. The trimLeft property is provided principally for compatibility with old code. It is recommended that the trimStart property be used in new ECMAScript code.

The initial value of the trimLeft property is the same function object as the initial value of the String.prototype.trimStart property.

Note

The property trimEnd is preferred. The trimRight property is provided principally for compatibility with old code. It is recommended that the trimEnd property be used in new ECMAScript code.

The initial value of the trimRight property is the same function object as the initial value of the String.prototype.trimEnd property.

Note

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 ? thisTimeValue(this value).
2. If t is NaN, return NaN.
3. Return YearFromTime(LocalTime(t)) - 1900.

Note

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 ? thisTimeValue(this value).
2. If t is NaN, set t to +0; otherwise, set t to LocalTime(t).
3. Let y be ? ToNumber(year).
4. If y is NaN, then
   1. Set the [[DateValue]] internal slot of this Date object to NaN.
   2. Return NaN.
5. Let yi be ! ToInteger(y).
6. If 0 ≤ yi ≤ 99, let yyyy be yi + 1900.
7. Else, let yyyy be y.
8. Let d be MakeDay(yyyy, MonthFromTime(t), DateFromTime(t)).
9. Let date be UTC(MakeDate(d, TimeWithinDay(t))).
10. Set the [[DateValue]] internal slot of this Date object to TimeClip(date).
11. Return the value of the [[DateValue]] internal slot of this Date object.

Note

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.

When the compile method is called with arguments pattern and flags, the following steps are taken:

1. Let O be the this value.
2. 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.
3. If Type(pattern) is Object and pattern has a [[RegExpMatcher]] internal slot, then
   1. If flags is not undefined, throw a TypeError exception.
   2. Let P be pattern.[[OriginalSource]].
   3. Let F be pattern.[[OriginalFlags]].
4. Else,
   1. Let P be pattern.
   2. Let F be flags.
5. Return ? RegExpInitialize(O, P, F).

Note

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.

During FunctionDeclarationInstantiation the following steps are performed in place of step 28:

1. If strict is false, then
   1. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause, do
      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 func and F is not an element of parameterNames, 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.
         2. If initializedBindings does not contain F and F is not "arguments", then
            1. Perform ! varEnvRec.CreateMutableBinding(F, false).
            2. Perform varEnvRec.InitializeBinding(F, undefined).
            3. Append F to instantiatedVarNames.
         3. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration Evaluation algorithm provided in 14.1.22:
            1. Let fenv be the running execution context's VariableEnvironment.
            2. Let fenvRec be fenv's EnvironmentRecord.
            3. Let benv be the running execution context's LexicalEnvironment.
            4. Let benvRec be benv's EnvironmentRecord.
            5. Let fobj be ! benvRec.GetBindingValue(F, false).
            6. Perform ! fenvRec.SetMutableBinding(F, fobj, false).
            7. Return NormalCompletion(empty).

During GlobalDeclarationInstantiation the following steps are performed in place of step 14:

1. Let strict be IsStrict of script.
2. If strict is false, then
   1. Let declaredFunctionOrVarNames be a new empty List.
   2. Append to declaredFunctionOrVarNames the elements of declaredFunctionNames.
   3. Append to declaredFunctionOrVarNames the elements of declaredVarNames.
   4. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause Contained within script, do
      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.CanDeclareGlobalVar(F).
            2. 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. Perform ? envRec.CreateGlobalVarBinding(F, false).
                  2. Append F to declaredFunctionOrVarNames.
               3. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration Evaluation algorithm provided in 14.1.22:
                  1. Let genv be the running execution context's VariableEnvironment.
                  2. Let genvRec be genv's EnvironmentRecord.
                  3. Let benv be the running execution context's LexicalEnvironment.
                  4. Let benvRec be benv's EnvironmentRecord.
                  5. Let fobj be ! benvRec.GetBindingValue(F, false).
                  6. Perform ? genvRec.SetMutableBinding(F, fobj, false).
                  7. Return NormalCompletion(empty).

During EvalDeclarationInstantiation the following steps are performed in place of step 9:

1. If strict is false, then
   1. Let declaredFunctionOrVarNames be a new empty List.
   2. Append to declaredFunctionOrVarNames the elements of declaredFunctionNames.
   3. Append to declaredFunctionOrVarNames the elements of declaredVarNames.
   4. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause Contained within body, do
      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.
         2. Let thisLex be lexEnv.
         3. Assert: The following loop will terminate.
         4. 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.
            3. Set thisLex to thisLex's outer environment reference.
         5. 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.CanDeclareGlobalVar(F).
            2. Else,
               1. Let fnDefinable be false.
         6. 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. Perform ? varEnvRec.CreateGlobalVarBinding(F, true).
               2. Else,
                  1. Let bindingExists be varEnvRec.HasBinding(F).
                  2. If bindingExists is false, then
                     1. Perform ! varEnvRec.CreateMutableBinding(F, true).
                     2. Perform ! varEnvRec.InitializeBinding(F, undefined).
               3. Append F to declaredFunctionOrVarNames.
            2. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration Evaluation algorithm provided in 14.1.22:
               1. Let genv be the running execution context's VariableEnvironment.
               2. Let genvRec be genv's EnvironmentRecord.
               3. Let benv be the running execution context's LexicalEnvironment.
               4. Let benvRec be benv's EnvironmentRecord.
               5. Let fobj be ! benvRec.GetBindingValue(F, false).
               6. Perform ? genvRec.SetMutableBinding(F, fobj, false).
               7. Return NormalCompletion(empty).

For web browser compatibility, that rule is modified with the addition of the highlighted text:

Block : { StatementList }

• It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains any duplicate entries, unless the source code matching this production is not strict mode code and the duplicate entries are only bound by FunctionDeclarations.

For web browser compatibility, that rule is modified with the addition of the highlighted text:

SwitchStatement : switch ( Expression ) CaseBlock

• It is a Syntax Error if the LexicallyDeclaredNames of CaseBlock contains any duplicate entries, unless the source code matching this production is not strict mode code and the duplicate entries are only bound by FunctionDeclarations.

During BlockDeclarationInstantiation the following steps are performed in place of step 4.a.ii.1:

1. If envRec.HasBinding(dn) is false, then
   1. Perform ! envRec.CreateMutableBinding(dn, false).

During BlockDeclarationInstantiation the following steps are performed in place of step 4.b.iii:

1. If envRec.HasBinding(fn) is false, then
   1. Perform envRec.InitializeBinding(fn, fo).
2. Else,
   1. Assert: d is a FunctionDeclaration.
   2. Perform envRec.SetMutableBinding(fn, fo, false).

The result column in Table 9 for an argument type of Object is replaced with the following algorithm:

1. If argument has an [[IsHTMLDDA]] internal slot, return false.
2. Return true.

The following steps are inserted after step 3 of the Abstract Equality Comparison algorithm:

1. If Type(x) is Object and x has an [[IsHTMLDDA]] internal slot and y is either null or undefined, return true.
2. If x is either null or undefined and Type(y) is Object and y has an [[IsHTMLDDA]] internal slot, return true.

The following table entry is inserted into Table 35 immediately preceeding the entry for "Object (implements [[Call]])":

Type of val	Result
Object (has an [[IsHTMLDDA]] internal slot)	"undefined"