The abstract operation PerformEval takes arguments source (an ECMAScript language value), strictCaller (a Boolean), and direct (a Boolean) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

1. Assert: If direct is false, then strictCaller is also false.
2. If source is not a String, return source.
3. Let evalRealm be the current Realm Record.
4. NOTE: In the case of a direct eval, evalRealm is the realm of both the caller of eval and of the eval function itself.
5. Perform ? HostEnsureCanCompileStrings(evalRealm, « », source, direct).
6. Let inFunc be false.
7. Let inMethod be false.
8. Let inDerivedCtor be false.
9. Let inClassFieldInitializer be false.
10. If direct is true, then
    1. Let thisEnvRecord be GetThisEnvironment().
    2. If thisEnvRecord is a Function Environment Record, then
       1. Let func be thisEnvRecord.[[FunctionObject]].
       2. Set inFunc to true.
       3. Set inMethod to thisEnvRecord.HasSuperBinding().
       4. If func.[[ConstructorKind]] is derived, set inDerivedCtor to true.
       5. Let classFieldInitializerName be func.[[ClassFieldInitializerName]].
       6. If classFieldInitializerName is not empty, set inClassFieldInitializer to true.
11. Perform the following substeps in an implementation-defined order, possibly interleaving parsing and error detection:
    1. Let script be ParseText(source, Script).
    2. If script is a List of errors, throw a SyntaxError exception.
    3. If script Contains ScriptBody is false, return undefined.
    4. Let body be the ScriptBody of script.
    5. If inFunc is false and body Contains NewTarget, throw a SyntaxError exception.
    6. If inMethod is false and body Contains SuperProperty, throw a SyntaxError exception.
    7. If inDerivedCtor is false and body Contains SuperCall, throw a SyntaxError exception.
    8. If inClassFieldInitializer is true and ContainsArguments of body is true, throw a SyntaxError exception.
12. If strictCaller is true, let strictEval be true.
13. Else, let strictEval be ScriptIsStrict of script.
14. Let runningContext be the running execution context.
15. NOTE: If direct is true, runningContext will be the execution context that performed the direct eval. If direct is false, runningContext will be the execution context for the invocation of the eval function.
16. If direct is true, then
    1. Let lexicalEnv be NewDeclarativeEnvironment(runningContext's LexicalEnvironment).
    2. Let variableEnv be runningContext's VariableEnvironment.
    3. Let privateEnv be runningContext's PrivateEnvironment.
17. Else,
    1. Let lexicalEnv be NewDeclarativeEnvironment(evalRealm.[[GlobalEnv]]).
    2. Let variableEnv be evalRealm.[[GlobalEnv]].
    3. Let privateEnv be null.
18. If strictEval is true, set variableEnv to lexicalEnv.
19. If runningContext is not already suspended, suspend runningContext.
20. Let evalContext be a new ECMAScript code execution context.
21. Set evalContext's Function to null.
22. Set evalContext's Realm to evalRealm.
23. Set evalContext's ScriptOrModule to runningContext's ScriptOrModule.
24. Set evalContext's VariableEnvironment to variableEnv.
25. Set evalContext's LexicalEnvironment to lexicalEnv.
26. Set evalContext's PrivateEnvironment to privateEnv.
27. Push evalContext onto the execution context stack; evalContext is now the running execution context.
28. Let result be Completion(EvalDeclarationInstantiation(body, variableEnv, lexicalEnv, privateEnv, strictEval)).
29. If result is a normal completion, then
    1. Set result to Completion(Evaluation of body).
30. If result is a normal completion and result.[[Value]] is empty, then
    1. Set result to NormalCompletion(undefined).
31. Suspend evalContext and remove it from the execution context stack.
32. Resume the context that is now on the top of the execution context stack as the running execution context.
33. Return ? result.

Note

The eval code cannot instantiate variable or function bindings in the variable environment of the calling context that invoked the eval if either the code of the calling context or the eval code is strict mode code. Instead such bindings are instantiated in a new VariableEnvironment that is only accessible to the eval code. Bindings introduced by let, const, or class declarations are always instantiated in a new LexicalEnvironment.

The host-defined abstract operation HostEnsureCanCompileStrings takes arguments calleeRealm (a Realm Record), paramStrings (a List of Strings), bodyString (a String), and direct (a Boolean) and returns either a normal completion containing unused or a throw completion. It allows host environments to block certain ECMAScript functions which allow developers to interpret and evaluate strings as ECMAScript code.

paramStrings represents the strings that, when using one of the function constructors, will be concatenated together to build the parameters list. bodyString represents the function body or the string passed to an eval call. direct signifies whether the evaluation is a direct eval.

The default implementation of HostEnsureCanCompileStrings is to return NormalCompletion(unused).

The abstract operation EvalDeclarationInstantiation takes arguments body (a ScriptBody Parse Node), variableEnv (an Environment Record), lexicalEnv (a Declarative Environment Record), privateEnv (a PrivateEnvironment Record or null), and strict (a Boolean) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

1. Let variableNames be the VarDeclaredNames of body.
2. Let variableDecls be the VarScopedDeclarations of body.
3. If strict is false, then
   1. If variableEnv is a Global Environment Record, then
      1. For each element name of variableNames, do
         1. If HasLexicalDeclaration(variableEnv, name) is true, throw a SyntaxError exception.
         2. NOTE: eval will not create a global var declaration that would be shadowed by a global lexical declaration.
   2. Let thisEnv be lexicalEnv.
   3. Assert: The following loop will terminate.
   4. Repeat, while thisEnv and variableEnv are not the same Environment Record,
      1. If thisEnv is not an Object Environment Record, then
         1. NOTE: The environment of with statements cannot contain any lexical declaration so it doesn't need to be checked for var/let hoisting conflicts.
         2. For each element name of variableNames, do
            1. If ! thisEnv.HasBinding(name) is true, then
               1. Normative Optional
                  If the host is a web browser or otherwise supports VariableStatements in Catch Blocks, then
                  1. If thisEnv is not the Environment Record for a Catch clause, throw a SyntaxError exception.
               2. Else,
                  1. Throw a SyntaxError exception.
            2. NOTE: A direct eval will not hoist var declaration over a like-named lexical declaration.
      2. Set thisEnv to thisEnv.[[OuterEnv]].
4. Let privateIdentifiers be a new empty List.
5. Let pointer be privateEnv.
6. Repeat, while pointer is not null,
   1. For each Private Name binding of pointer.[[Names]], do
      1. If privateIdentifiers does not contain binding.[[Description]], append binding.[[Description]] to privateIdentifiers.
   2. Set pointer to pointer.[[OuterPrivateEnvironment]].
7. If AllPrivateIdentifiersValid of body with argument privateIdentifiers is false, throw a SyntaxError exception.
8. Let funcsToInitialize be a new empty List.
9. Let declaredFuncNames be a new empty List.
10. For each element d of variableDecls, in reverse List order, do
    1. If d is not either a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
       1. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
       2. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
       3. Let func be the sole element of the BoundNames of d.
       4. If declaredFuncNames does not contain func, then
          1. If variableEnv is a Global Environment Record, then
             1. Let funcDefinable be ? CanDeclareGlobalFunction(variableEnv, func).
             2. If funcDefinable is false, throw a TypeError exception.
          2. Append func to declaredFuncNames.
          3. Insert d as the first element of funcsToInitialize.
11. Let declaredVariableNames be a new empty List.
12. For each element d of variableDecls, do
    1. If d is either a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
       1. For each String vn of the BoundNames of d, do
          1. If declaredFuncNames does not contain vn, then
             1. If variableEnv is a Global Environment Record, then
                1. Let vnDefinable be ? CanDeclareGlobalVar(variableEnv, vn).
                2. If vnDefinable is false, throw a TypeError exception.
             2. If declaredVariableNames does not contain vn, then
                1. Append vn to declaredVariableNames.
13. Normative Optional
    If strict is false and the host is a web browser or otherwise supports Block-Level Function Declarations Web Legacy Compatibility Semantics, then
    1. Let declaredFuncOrVariableNames be the list-concatenation of declaredFuncNames and declaredVariableNames.
    2. For each FunctionDeclaration f that is directly contained in the StatementList of any Block, CaseClause, or DefaultClause x such that body Contains x is true, do
       1. Let funcName be the StringValue of the BindingIdentifier of f.
       2. If replacing the FunctionDeclaration f with a VariableStatement that has funcName as a BindingIdentifier would not produce any Early Errors for body, then
          1. Let bindingExists be false.
          2. Set thisEnv to lexicalEnv.
          3. Assert: The following loop will terminate.
          4. Repeat, while thisEnv is not variableEnv,
             1. If thisEnv is not an Object Environment Record, then
                1. If ! thisEnv.HasBinding(funcName) is true, then
                   1. Normative Optional
                      If the host is a web browser or otherwise supports VariableStatements in Catch Blocks, then
                      1. If thisEnv is not the Environment Record for a Catch clause, set bindingExists to true.
                   2. Else,
                      1. Set bindingExists to true.
             2. Set thisEnv to thisEnv.[[OuterEnv]].
          5. If bindingExists is false and variableEnv is a Global Environment Record, then
             1. If HasLexicalDeclaration(variableEnv, funcName) is false, then
                1. Let funcDefinable be ? CanDeclareGlobalVar(variableEnv, funcName).
             2. Else,
                1. Let funcDefinable be false.
          6. Else,
             1. Let funcDefinable be true.
          7. If bindingExists is false and funcDefinable is true, then
             1. If declaredFuncOrVariableNames does not contain funcName, then
                1. If variableEnv is a Global Environment Record, then
                   1. Perform ? CreateGlobalVarBinding(variableEnv, funcName, true).
                2. Else,
                   1. Set bindingExists to ! variableEnv.HasBinding(funcName).
                   2. If bindingExists is false, then
                      1. Perform ! variableEnv.CreateMutableBinding(funcName, true).
                      2. Perform ! variableEnv.InitializeBinding(funcName, undefined).
                3. Append funcName to declaredFuncOrVariableNames.
             2. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration Evaluation algorithm provided in 15.2.6:
                1. Let gEnv be the running execution context's VariableEnvironment.
                2. Let bEnv be the running execution context's LexicalEnvironment.
                3. Let fObj be ! bEnv.GetBindingValue(funcName, false).
                4. Perform ? gEnv.SetMutableBinding(funcName, fObj, false).
                5. Return unused.
14. NOTE: No abnormal terminations occur after this algorithm step unless variableEnv is a Global Environment Record and the global object is a Proxy exotic object.
15. Let lexicalDecls be the LexicallyScopedDeclarations of body.
16. For each element d of lexicalDecls, do
    1. NOTE: Lexically declared names are only instantiated here but not initialized.
    2. For each element dn of the BoundNames of d, do
       1. If IsConstantDeclaration of d is true, then
          1. Perform ? lexicalEnv.CreateImmutableBinding(dn, true).
       2. Else,
          1. Perform ? lexicalEnv.CreateMutableBinding(dn, false).
17. For each Parse Node f of funcsToInitialize, do
    1. Let func be the sole element of the BoundNames of f.
    2. Let funcObj be InstantiateFunctionObject of f with arguments lexicalEnv and privateEnv.
    3. If variableEnv is a Global Environment Record, then
       1. Perform ? CreateGlobalFunctionBinding(variableEnv, func, funcObj, true).
    4. Else,
       1. Let bindingExists be ! variableEnv.HasBinding(func).
       2. If bindingExists is false, then
          1. NOTE: The following invocation cannot return an abrupt completion because of the validation preceding step 14.
          2. Perform ! variableEnv.CreateMutableBinding(func, true).
          3. Perform ! variableEnv.InitializeBinding(func, funcObj).
       3. Else,
          1. Perform ! variableEnv.SetMutableBinding(func, funcObj, false).
18. For each String vn of declaredVariableNames, do
    1. If variableEnv is a Global Environment Record, then
       1. Perform ? CreateGlobalVarBinding(variableEnv, vn, true).
    2. Else,
       1. Let bindingExists be ! variableEnv.HasBinding(vn).
       2. If bindingExists is false, then
          1. NOTE: The following invocation cannot return an abrupt completion because of the validation preceding step 14.
          2. Perform ! variableEnv.CreateMutableBinding(vn, true).
          3. Perform ! variableEnv.InitializeBinding(vn, undefined).
19. Return unused.

This function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the encodeURI function is replaced with the UTF-16 encoding of the code point that it represents. Escape sequences that could not have been introduced by encodeURI are not replaced.

It is the %decodeURI% intrinsic object.

It performs the following steps when called:

1. Let uriString be ? ToString(encodedURI).
2. Let preserveEscapeSet be ";/?:@&=+$,#".
3. Return ? Decode(uriString, preserveEscapeSet).

This function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the encodeURIComponent function is replaced with the UTF-16 encoding of the code point that it represents.

It is the %decodeURIComponent% intrinsic object.

It performs the following steps when called:

1. Let componentString be ? ToString(encodedURIComponent).
2. Let preserveEscapeSet be the empty String.
3. Return ? Decode(componentString, preserveEscapeSet).

This function computes a new version of a UTF-16 encoded (6.1.4) URI in which each instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the code point.

It is the %encodeURI% intrinsic object.

It performs the following steps when called:

1. Let uriString be ? ToString(uri).
2. Let extraUnescaped be ";/?:@&=+$,#".
3. Return ? Encode(uriString, extraUnescaped).

This function computes a new version of a UTF-16 encoded (6.1.4) URI in which each instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the code point.

It is the %encodeURIComponent% intrinsic object.

It performs the following steps when called:

1. Let componentString be ? ToString(uriComponent).
2. Let extraUnescaped be the empty String.
3. Return ? Encode(componentString, extraUnescaped).

The abstract operation Encode takes arguments string (a String) and extraUnescaped (a String) and returns either a normal completion containing a String or a throw completion. It performs URI encoding and escaping, interpreting string as a sequence of UTF-16 encoded code points as described in 6.1.4. If a character is identified as unreserved in RFC 2396 or appears in extraUnescaped, it is not escaped. It performs the following steps when called:

1. Let length be the length of string.
2. Let result be the empty String.
3. Let alwaysUnescaped be the string-concatenation of the ASCII word characters and "-.!~*'()".
4. Let unescapedSet be the string-concatenation of alwaysUnescaped and extraUnescaped.
5. Let k be 0.
6. Repeat, while k < length,
   1. Let codeUnit be the code unit at index k within string.
   2. If unescapedSet contains codeUnit, then
      1. Set k to k + 1.
      2. Set result to the string-concatenation of result and codeUnit.
   3. Else,
      1. Let codePoint be CodePointAt(string, k).
      2. If codePoint.[[IsUnpairedSurrogate]] is true, throw a URIError exception.
      3. Set k to k + codePoint.[[CodeUnitCount]].
      4. Let octets be the List of octets resulting by applying the UTF-8 transformation to codePoint.[[CodePoint]].
      5. For each element octet of octets, do
         1. Let hex be the String representation of octet, formatted as an uppercase hexadecimal number.
         2. Set result to the string-concatenation of result, "%", and StringPad(hex, 2, "0", start).
7. Return result.

Note

Because percent-encoding is used to represent individual octets, a single code point may be expressed as multiple consecutive escape sequences (one for each of its 8-bit UTF-8 code units).

The abstract operation Decode takes arguments string (a String) and preserveEscapeSet (a String) and returns either a normal completion containing a String or a throw completion. It performs URI unescaping and decoding, preserving any escape sequences that correspond to Basic Latin characters in preserveEscapeSet. It performs the following steps when called:

1. Let length be the length of string.
2. Let result be the empty String.
3. Let k be 0.
4. Repeat, while k < length,
   1. Let codeUnit be the code unit at index k within string.
   2. Let segment be codeUnit.
   3. If codeUnit is the code unit 0x0025 (PERCENT SIGN), then
      1. If k + 3 > length, throw a URIError exception.
      2. Let escape be the substring of string from k to k + 3.
      3. Let firstOctet be ParseHexOctet(string, k + 1).
      4. If firstOctet is not an integer, throw a URIError exception.
      5. Set k to k + 2.
      6. Let n be the number of leading 1 bits in firstOctet.
      7. If n = 0, then
         1. Let asciiChar be the code unit whose numeric value is firstOctet.
         2. If preserveEscapeSet contains asciiChar, set segment to escape; else set segment to asciiChar.
      8. Else,
         1. If n = 1 or n > 4, throw a URIError exception.
         2. Let octets be « firstOctet ».
         3. Let j be 1.
         4. Repeat, while j < n,
            1. Set k to k + 1.
            2. If k + 3 > length, throw a URIError exception.
            3. If the code unit at index k within string is not the code unit 0x0025 (PERCENT SIGN), throw a URIError exception.
            4. Let continuationByte be ParseHexOctet(string, k + 1).
            5. If continuationByte is not an integer, throw a URIError exception.
            6. Append continuationByte to octets.
            7. Set k to k + 2.
            8. Set j to j + 1.
         5. Assert: The length of octets is n.
         6. If octets does not contain a valid UTF-8 encoding of a Unicode code point, throw a URIError exception.
         7. Let codePoint be the code point obtained by applying the UTF-8 transformation to octets, that is, from a List of octets into a 21-bit value.
         8. Set segment to UTF16EncodeCodePoint(codePoint).
   4. Set result to the string-concatenation of result and segment.
   5. Set k to k + 1.
5. Return result.

Note

RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. For example, the invalid sequence 0xC0 0x80 must not decode into the code unit 0x0000. Implementations of the Decode algorithm are required to throw a URIError when encountering such invalid sequences.

The abstract operation ParseHexOctet takes arguments string (a String) and position (a non-negative integer) and returns either a non-negative integer or a non-empty List of SyntaxError objects. It parses a sequence of two hexadecimal characters at the specified position in string into an unsigned 8-bit integer. It performs the following steps when called:

1. Let length be the length of string.
2. Assert: position + 2 ≤ length.
3. Let hexDigits be the substring of string from position to position + 2.
4. Let parseResult be ParseText(hexDigits, HexDigits[~Sep]).
5. If parseResult is not a Parse Node, return parseResult.
6. Let n be the MV of parseResult.
7. Assert: n is in the inclusive interval from 0 to 255.
8. Return n.