@next-core/cook 1.6.78 → 1.6.79

package/dist/cjs/cook.js

@@ -4,15 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.cook = cook;
-
 var _contextFree = require("./context-free");
-
 var _ExecutionContext = require("./ExecutionContext");
-
 var _sanitize = require("./sanitize");
-
 var _traverse = require("./traverse");
-
 /** For next-core internal usage only. */
 function cook(rootAst, codeSource, {
   rules,
@@ -20,28 +15,24 @@ function cook(rootAst, codeSource, {
   hooks = {}
 } = {}) {
   var _hooks$beforeEvaluate3;
-
   const expressionOnly = rootAst.type !== "FunctionDeclaration";
   const rootEnv = new _ExecutionContext.DeclarativeEnvironment(null);
   const rootContext = new _ExecutionContext.ExecutionContext();
   rootContext.VariableEnvironment = rootEnv;
   rootContext.LexicalEnvironment = rootEnv;
   const executionContextStack = [rootContext];
-
   for (const [key, value] of Object.entries(globalVariables)) {
     rootEnv.CreateImmutableBinding(key, true);
     rootEnv.InitializeBinding(key, value);
   }
+  const TemplateMap = new WeakMap();
 
-  const TemplateMap = new WeakMap(); // https://tc39.es/ecma262/#sec-gettemplateobject
-
+  // https://tc39.es/ecma262/#sec-gettemplateobject
   function GetTemplateObject(templateLiteral) {
     const memo = TemplateMap.get(templateLiteral);
-
     if (memo) {
       return memo;
     }
-
     const rawObj = templateLiteral.quasis.map(quasi => quasi.value.raw);
     const template = templateLiteral.quasis.map(quasi => quasi.value.cooked);
     Object.freeze(rawObj);
@@ -55,18 +46,15 @@ function cook(rootAst, codeSource, {
     TemplateMap.set(templateLiteral, template);
     return template;
   }
-
   function Evaluate(node, optionalChainRef) {
     var _hooks$beforeEvaluate, _hooks$beforeBranch, _hooks$beforeBranch2;
-
-    (_hooks$beforeEvaluate = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate === void 0 ? void 0 : _hooks$beforeEvaluate.call(hooks, node); // Expressions:
-
+    (_hooks$beforeEvaluate = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate === void 0 ? void 0 : _hooks$beforeEvaluate.call(hooks, node);
+    // Expressions:
     switch (node.type) {
       case "ArrayExpression":
         {
           // https://tc39.es/ecma262/#sec-array-initializer
           const array = [];
-
           for (const element of node.elements) {
             if (!element) {
               array.length += 1;
@@ -77,10 +65,8 @@ function cook(rootAst, codeSource, {
               array.push((0, _contextFree.GetValue)(Evaluate(element)));
             }
           }
-
           return (0, _ExecutionContext.NormalCompletion)(array);
         }
-
       case "ArrowFunctionExpression":
         {
           // https://tc39.es/ecma262/#sec-arrow-function-definitions
@@ -88,14 +74,12 @@ function cook(rootAst, codeSource, {
           const closure = InstantiateArrowFunctionExpression(node);
           return (0, _ExecutionContext.NormalCompletion)(closure);
         }
-
       case "BinaryExpression":
         {
           const leftRef = Evaluate(node.left);
           const leftValue = (0, _contextFree.GetValue)(leftRef);
           const rightRef = Evaluate(node.right).Value;
           const rightValue = (0, _contextFree.GetValue)(rightRef);
-
           if (expressionOnly && node.operator === "|>") {
             // Minimal pipeline operator is supported only in expression-only mode.
             // See https://tc39.es/proposal-pipeline-operator
@@ -104,50 +88,39 @@ function cook(rootAst, codeSource, {
               const funcName = codeSource.substring(node.right.start, node.right.end);
               throw new TypeError(`${funcName} is not a function`);
             }
-
             let thisValue;
-
             if (rightRef instanceof _ExecutionContext.ReferenceRecord) {
               if ((0, _contextFree.IsPropertyReference)(rightRef)) {
                 thisValue = rightRef.Base;
               }
             }
-
             return (0, _ExecutionContext.NormalCompletion)(rightValue.call(thisValue, leftValue));
-          } // https://tc39.es/ecma262/#sec-additive-operators
-
-
+          }
+          // https://tc39.es/ecma262/#sec-additive-operators
           const result = (0, _contextFree.ApplyStringOrNumericBinaryOperator)(leftValue, node.operator, rightValue);
           return (0, _ExecutionContext.NormalCompletion)(result);
         }
-
       case "CallExpression":
         {
           // https://tc39.es/ecma262/#sec-function-calls
           const ref = Evaluate(node.callee, optionalChainRef).Value;
           const func = (0, _contextFree.GetValue)(ref);
-
           if ((func === undefined || func === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return (0, _ExecutionContext.NormalCompletion)(undefined);
           }
-
           (0, _sanitize.sanitize)(func);
           return EvaluateCall(func, ref, node.arguments, node.callee);
         }
-
       case "ChainExpression":
         // https://tc39.es/ecma262/#sec-optional-chains
         return Evaluate(node.expression, {});
-
       case "ConditionalExpression":
         // https://tc39.es/ecma262/#sec-conditional-operator
         return (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(Evaluate((0, _contextFree.GetValue)(Evaluate(node.test)) ? node.consequent : node.alternate)));
-
       case "Identifier":
         // https://tc39.es/ecma262/#sec-identifiers
         return (0, _ExecutionContext.NormalCompletion)(ResolveBinding(node.name));
-
       case "Literal":
         {
           // https://tc39.es/ecma262/#sec-primary-expression-literals
@@ -156,65 +129,53 @@ function cook(rootAst, codeSource, {
               // Invalid regular expression fails silently in @babel/parser.
               throw new SyntaxError(`Invalid regular expression: ${node.raw}`);
             }
-
             if (node.regex.flags.includes("u")) {
               // Currently unicode flag is not fully supported across major browsers.
               throw new SyntaxError(`Unsupported unicode flag in regular expression: ${node.raw}`);
             }
           }
-
           return (0, _ExecutionContext.NormalCompletion)(node.value);
         }
-
       case "LogicalExpression":
         {
           // https://tc39.es/ecma262/#sec-binary-logical-operators
           const leftValue = (0, _contextFree.GetValue)(Evaluate(node.left));
-
           switch (node.operator) {
             case "&&":
               return (0, _ExecutionContext.NormalCompletion)(leftValue && (0, _contextFree.GetValue)(Evaluate(node.right)));
-
             case "||":
               return (0, _ExecutionContext.NormalCompletion)(leftValue || (0, _contextFree.GetValue)(Evaluate(node.right)));
-
             case "??":
               return (0, _ExecutionContext.NormalCompletion)(leftValue !== null && leftValue !== void 0 ? leftValue : (0, _contextFree.GetValue)(Evaluate(node.right)));
             // istanbul ignore next
-
             default:
-              throw new SyntaxError( // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              throw new SyntaxError(
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
               // @ts-ignore never reach here.
               `Unsupported logical operator '${node.operator}'`);
           }
         }
-
       case "MemberExpression":
         {
           // https://tc39.es/ecma262/#sec-property-accessors
           const baseReference = Evaluate(node.object, optionalChainRef).Value;
           const baseValue = (0, _contextFree.GetValue)(baseReference);
-
           if ((baseValue === undefined || baseValue === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return (0, _ExecutionContext.NormalCompletion)(undefined);
           }
-
           (0, _sanitize.sanitize)(baseValue);
           const result = node.computed ? EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
           (0, _sanitize.sanitize)(result);
           return (0, _ExecutionContext.NormalCompletion)(result);
         }
-
       case "NewExpression":
         // https://tc39.es/ecma262/#sec-new-operator
         return EvaluateNew(node.callee, node.arguments);
-
       case "ObjectExpression":
         {
           // https://tc39.es/ecma262/#sec-object-initializer
           const object = {};
-
           for (const prop of node.properties) {
             if (prop.type === "SpreadElement") {
               const fromValue = (0, _contextFree.GetValue)(Evaluate(prop.argument));
@@ -223,47 +184,36 @@ function cook(rootAst, codeSource, {
               if (prop.kind !== "init") {
                 throw new SyntaxError("Unsupported object getter/setter");
               }
-
               const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : EvaluateComputedPropertyName(prop.key);
-
               if (propName === "__proto__") {
                 throw new TypeError("Setting '__proto__' property is not allowed");
               }
-
               object[propName] = (0, _contextFree.GetValue)(Evaluate(prop.value));
             }
           }
-
           return (0, _ExecutionContext.NormalCompletion)(object);
         }
-
       case "SequenceExpression":
         {
           // https://tc39.es/ecma262/#sec-comma-operator
           let result;
-
           for (const expr of node.expressions) {
             result = (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(Evaluate(expr)));
           }
-
           return result;
         }
-
       case "TemplateLiteral":
         {
           // https://tc39.es/ecma262/#sec-template-literals
           const chunks = [node.quasis[0].value.cooked];
           let index = 0;
-
           for (const expr of node.expressions) {
             const val = (0, _contextFree.GetValue)(Evaluate(expr));
             chunks.push(String(val));
             chunks.push(node.quasis[index += 1].value.cooked);
           }
-
           return (0, _ExecutionContext.NormalCompletion)(chunks.join(""));
         }
-
       case "TaggedTemplateExpression":
         {
           // https://tc39.es/ecma262/#sec-tagged-templates
@@ -272,38 +222,32 @@ function cook(rootAst, codeSource, {
           (0, _sanitize.sanitize)(tagFunc);
           return EvaluateCall(tagFunc, tagRef, node.quasi, node.tag);
         }
-
       case "UnaryExpression":
         {
           // https://tc39.es/ecma262/#sec-unary-operators
           const ref = Evaluate(node.argument).Value;
-
           if (!expressionOnly && node.operator === "delete") {
             // Delete operator is supported only in function mode.
             if (!(ref instanceof _ExecutionContext.ReferenceRecord)) {
               return (0, _ExecutionContext.NormalCompletion)(true);
-            } // istanbul ignore else
-
-
+            }
+            // istanbul ignore else
             if ((0, _contextFree.IsPropertyReference)(ref)) {
               const deleteStatus = delete ref.Base[ref.ReferenceName];
               return (0, _ExecutionContext.NormalCompletion)(deleteStatus);
-            } // Should never reach here in strict mode.
-
+            }
+            // Should never reach here in strict mode.
           }
 
           if (node.operator === "typeof") {
             if (ref instanceof _ExecutionContext.ReferenceRecord && ref.Base === "unresolvable") {
               return (0, _ExecutionContext.NormalCompletion)("undefined");
             }
-
             return (0, _ExecutionContext.NormalCompletion)(typeof (0, _contextFree.GetValue)(ref));
           }
-
           return (0, _ExecutionContext.NormalCompletion)((0, _contextFree.ApplyUnaryOperator)((0, _contextFree.GetValue)(ref), node.operator));
         }
     }
-
     if (!expressionOnly) {
       // Statements and assignments:
       switch (node.type) {
@@ -312,21 +256,19 @@ function cook(rootAst, codeSource, {
             // https://tc39.es/ecma262/#sec-assignment-operators
             if (node.operator === "=") {
               if (!(node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern")) {
-                const lref = Evaluate(node.left).Value; // Todo: IsAnonymousFunctionDefinition(lref)
-
+                const lref = Evaluate(node.left).Value;
+                // Todo: IsAnonymousFunctionDefinition(lref)
                 const rref = Evaluate(node.right);
                 const rval = (0, _contextFree.GetValue)(rref);
                 (0, _contextFree.PutValue)(lref, rval);
                 return (0, _ExecutionContext.NormalCompletion)(rval);
               }
-
               const rref = Evaluate(node.right);
               const rval = (0, _contextFree.GetValue)(rref);
               DestructuringAssignmentEvaluation(node.left, rval);
               return (0, _ExecutionContext.NormalCompletion)(rval);
-            } // Operators other than `=`.
-
-
+            }
+            // Operators other than `=`.
             const lref = Evaluate(node.left).Value;
             const lval = (0, _contextFree.GetValue)(lref);
             const rref = Evaluate(node.right);
@@ -335,14 +277,12 @@ function cook(rootAst, codeSource, {
             (0, _contextFree.PutValue)(lref, r);
             return (0, _ExecutionContext.NormalCompletion)(r);
           }
-
         case "BlockStatement":
           {
             // https://tc39.es/ecma262/#sec-block
             if (!node.body.length) {
               return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
             }
-
             const oldEnv = getRunningContext().LexicalEnvironment;
             const blockEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
             BlockDeclarationInstantiation(node.body, blockEnv);
@@ -351,67 +291,52 @@ function cook(rootAst, codeSource, {
             getRunningContext().LexicalEnvironment = oldEnv;
             return blockValue;
           }
-
         case "BreakStatement":
           // https://tc39.es/ecma262/#sec-break-statement
           return new _ExecutionContext.CompletionRecord("break", _ExecutionContext.Empty);
-
         case "ContinueStatement":
           // https://tc39.es/ecma262/#sec-continue-statement
           return new _ExecutionContext.CompletionRecord("continue", _ExecutionContext.Empty);
-
         case "EmptyStatement":
           // https://tc39.es/ecma262/#sec-empty-statement
           return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
-
         case "DoWhileStatement":
           // https://tc39.es/ecma262/#sec-do-while-statement
           return EvaluateBreakableStatement(DoWhileLoopEvaluation(node));
-
         case "ExpressionStatement":
         case "TSAsExpression":
           // https://tc39.es/ecma262/#sec-expression-statement
           return Evaluate(node.expression);
-
         case "ForInStatement":
         case "ForOfStatement":
           // https://tc39.es/ecma262/#sec-for-in-and-for-of-statements
           return EvaluateBreakableStatement(ForInOfLoopEvaluation(node));
-
         case "ForStatement":
           // https://tc39.es/ecma262/#sec-for-statement
           return EvaluateBreakableStatement(ForLoopEvaluation(node));
-
         case "FunctionDeclaration":
           // https://tc39.es/ecma262/#sec-function-definitions
           return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
-
         case "FunctionExpression":
           // https://tc39.es/ecma262/#sec-function-defining-expressions
           ThrowIfFunctionIsInvalid(node);
           return (0, _ExecutionContext.NormalCompletion)(InstantiateOrdinaryFunctionExpression(node));
-
         case "IfStatement":
           // https://tc39.es/ecma262/#sec-if-statement
           return (0, _contextFree.GetValue)(Evaluate(node.test)) ? ((_hooks$beforeBranch = hooks.beforeBranch) !== null && _hooks$beforeBranch !== void 0 && _hooks$beforeBranch.call(hooks, node, "if"), (0, _contextFree.UpdateEmpty)(Evaluate(node.consequent), undefined)) : ((_hooks$beforeBranch2 = hooks.beforeBranch) !== null && _hooks$beforeBranch2 !== void 0 && _hooks$beforeBranch2.call(hooks, node, "else"), node.alternate) ? (0, _contextFree.UpdateEmpty)(Evaluate(node.alternate), undefined) : (0, _ExecutionContext.NormalCompletion)(undefined);
-
         case "ReturnStatement":
           {
             // https://tc39.es/ecma262/#sec-return-statement
             let v;
-
             if (node.argument) {
               const exprRef = Evaluate(node.argument);
               v = (0, _contextFree.GetValue)(exprRef);
             }
-
             return new _ExecutionContext.CompletionRecord("return", v);
           }
-
         case "ThrowStatement":
           // https://tc39.es/ecma262/#sec-throw-statement
           throw (0, _contextFree.GetValue)(Evaluate(node.argument));
-
         case "UpdateExpression":
           {
             // https://tc39.es/ecma262/#sec-update-expressions
@@ -421,10 +346,8 @@ function cook(rootAst, codeSource, {
             (0, _contextFree.PutValue)(lhs, newValue);
             return (0, _ExecutionContext.NormalCompletion)(node.prefix ? newValue : oldValue);
           }
-
         case "SwitchCase":
           return EvaluateStatementList(node.consequent);
-
         case "SwitchStatement":
           {
             // https://tc39.es/ecma262/#sec-switch-statement
@@ -438,18 +361,15 @@ function cook(rootAst, codeSource, {
             getRunningContext().LexicalEnvironment = oldEnv;
             return EvaluateBreakableStatement(R);
           }
-
         case "TryStatement":
           {
             // https://tc39.es/ecma262/#sec-try-statement
             let R;
-
             try {
               R = Evaluate(node.block);
             } catch (error) {
               if (node.handler) {
                 var _hooks$beforeEvaluate2;
-
                 (_hooks$beforeEvaluate2 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate2 === void 0 ? void 0 : _hooks$beforeEvaluate2.call(hooks, node.handler);
                 R = CatchClauseEvaluation(node.handler, error);
               } else {
@@ -458,21 +378,17 @@ function cook(rootAst, codeSource, {
             } finally {
               if (node.finalizer) {
                 const F = Evaluate(node.finalizer);
-
                 if (F.Type !== "normal") {
                   R = F;
                 }
               }
             }
-
             return R;
           }
-
         case "VariableDeclaration":
           {
             // https://tc39.es/ecma262/#sec-declarations-and-the-variable-statement
             let result;
-
             for (const declarator of node.declarations) {
               if (!declarator.init) {
                 // Assert: a declarator without init is always an identifier.
@@ -484,8 +400,8 @@ function cook(rootAst, codeSource, {
                 }
               } else if (declarator.id.type === "Identifier") {
                 const bindingId = declarator.id.name;
-                const lhs = ResolveBinding(bindingId); // Todo: IsAnonymousFunctionDefinition(Initializer)
-
+                const lhs = ResolveBinding(bindingId);
+                // Todo: IsAnonymousFunctionDefinition(Initializer)
                 const rhs = Evaluate(declarator.init);
                 const value = (0, _contextFree.GetValue)(rhs);
                 result = node.kind === "var" ? (0, _contextFree.PutValue)(lhs, value) : (0, _contextFree.InitializeReferencedBinding)(lhs, value);
@@ -495,197 +411,166 @@ function cook(rootAst, codeSource, {
                 result = BindingInitialization(declarator.id, rval, node.kind === "var" ? undefined : getRunningContext().LexicalEnvironment);
               }
             }
-
             return result;
           }
-
         case "WhileStatement":
           // https://tc39.es/ecma262/#sec-while-statement
           return EvaluateBreakableStatement(WhileLoopEvaluation(node));
       }
-    } // eslint-disable-next-line no-console
-
-
+    }
+    // eslint-disable-next-line no-console
     throw new SyntaxError(`Unsupported node type \`${node.type}\``);
-  } // https://tc39.es/ecma262/#sec-execution-contexts
-
+  }
 
+  // https://tc39.es/ecma262/#sec-execution-contexts
   function getRunningContext() {
     return executionContextStack[executionContextStack.length - 1];
-  } // https://tc39.es/ecma262/#sec-resolvebinding
-
+  }
 
+  // https://tc39.es/ecma262/#sec-resolvebinding
   function ResolveBinding(name, env) {
     if (!env) {
       env = getRunningContext().LexicalEnvironment;
     }
-
     return (0, _contextFree.GetIdentifierReference)(env, name, true);
-  } // Try statements.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation
-
+  }
 
+  // Try statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation
   function CatchClauseEvaluation(node, thrownValue) {
     const oldEnv = getRunningContext().LexicalEnvironment;
     const catchEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
-
     for (const argName of (0, _traverse.collectBoundNames)(node.param)) {
       catchEnv.CreateMutableBinding(argName, false);
     }
-
     getRunningContext().LexicalEnvironment = catchEnv;
     BindingInitialization(node.param, thrownValue, catchEnv);
     const B = Evaluate(node.body);
     getRunningContext().LexicalEnvironment = oldEnv;
     return B;
-  } // Iteration statements and switch statements.
-  // https://tc39.es/ecma262/#prod-BreakableStatement
-
+  }
 
+  // Iteration statements and switch statements.
+  // https://tc39.es/ecma262/#prod-BreakableStatement
   function EvaluateBreakableStatement(stmtResult) {
     return stmtResult.Type === "break" ? stmtResult.Value === _ExecutionContext.Empty ? (0, _ExecutionContext.NormalCompletion)(undefined) : (0, _ExecutionContext.NormalCompletion)(stmtResult.Value) : stmtResult;
-  } // Switch statements.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
-
+  }
 
+  // Switch statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
   function CaseBlockEvaluation(cases, input) {
     let V;
     const defaultCaseIndex = cases.findIndex(switchCase => !switchCase.test);
     const hasDefaultCase = defaultCaseIndex >= 0;
     const A = hasDefaultCase ? cases.slice(0, defaultCaseIndex) : cases;
     let found = false;
-
     for (const C of A) {
       if (!found) {
         found = CaseClauseIsSelected(C, input);
       }
-
       if (found) {
         const R = Evaluate(C);
-
         if (R.Value !== _ExecutionContext.Empty) {
           V = R.Value;
         }
-
         if (R.Type !== "normal") {
           return (0, _contextFree.UpdateEmpty)(R, V);
         }
       }
     }
-
     if (!hasDefaultCase) {
       return (0, _ExecutionContext.NormalCompletion)(V);
     }
-
     let foundInB = false;
     const B = cases.slice(defaultCaseIndex + 1);
-
     if (!found) {
       for (const C of B) {
         if (!foundInB) {
           foundInB = CaseClauseIsSelected(C, input);
         }
-
         if (foundInB) {
           const R = Evaluate(C);
-
           if (R.Value !== _ExecutionContext.Empty) {
             V = R.Value;
           }
-
           if (R.Type !== "normal") {
             return (0, _contextFree.UpdateEmpty)(R, V);
           }
         }
       }
     }
-
     if (foundInB) {
       return (0, _ExecutionContext.NormalCompletion)(V);
     }
-
     const R = Evaluate(cases[defaultCaseIndex]);
-
     if (R.Value !== _ExecutionContext.Empty) {
       V = R.Value;
     }
-
     if (R.Type !== "normal") {
       return (0, _contextFree.UpdateEmpty)(R, V);
-    } // NOTE: The following is another complete iteration of the second CaseClauses.
-
+    }
 
+    // NOTE: The following is another complete iteration of the second CaseClauses.
     for (const C of B) {
       const R = Evaluate(C);
-
       if (R.Value !== _ExecutionContext.Empty) {
         V = R.Value;
       }
-
       if (R.Type !== "normal") {
         return (0, _contextFree.UpdateEmpty)(R, V);
       }
     }
-
     return (0, _ExecutionContext.NormalCompletion)(V);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
   function CaseClauseIsSelected(C, input) {
     const clauseSelector = (0, _contextFree.GetValue)(Evaluate(C.test));
     return input === clauseSelector;
-  } // While statements.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-whileloopevaluation
-
+  }
 
+  // While statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-whileloopevaluation
   function WhileLoopEvaluation(node) {
-    let V; // eslint-disable-next-line no-constant-condition
-
+    let V;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       const exprValue = (0, _contextFree.GetValue)(Evaluate(node.test));
-
       if (!exprValue) {
         return (0, _ExecutionContext.NormalCompletion)(V);
       }
-
       const stmtResult = Evaluate(node.body);
-
       if (!(0, _contextFree.LoopContinues)(stmtResult)) {
         return (0, _contextFree.UpdateEmpty)(stmtResult, V);
       }
-
       if (stmtResult.Value !== _ExecutionContext.Empty) {
         V = stmtResult.Value;
       }
     }
-  } // Do-while Statements.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-dowhileloopevaluation
-
+  }
 
+  // Do-while Statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-dowhileloopevaluation
   function DoWhileLoopEvaluation(node) {
-    let V; // eslint-disable-next-line no-constant-condition
-
+    let V;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       const stmtResult = Evaluate(node.body);
-
       if (!(0, _contextFree.LoopContinues)(stmtResult)) {
         return (0, _contextFree.UpdateEmpty)(stmtResult, V);
       }
-
       if (stmtResult.Value !== _ExecutionContext.Empty) {
         V = stmtResult.Value;
       }
-
       const exprValue = (0, _contextFree.GetValue)(Evaluate(node.test));
-
       if (!exprValue) {
         return (0, _ExecutionContext.NormalCompletion)(V);
       }
     }
-  } // For in/of statements.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
-
+  }
 
+  // For in/of statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
   function ForInOfLoopEvaluation(node) {
     const lhs = node.left;
     const isVariableDeclaration = lhs.type === "VariableDeclaration";
@@ -693,76 +578,62 @@ function cook(rootAst, codeSource, {
     const uninitializedBoundNames = lhsKind === "lexicalBinding" ? (0, _traverse.collectBoundNames)(lhs) : [];
     const iterationKind = node.type === "ForInStatement" ? "enumerate" : "iterate";
     const keyResult = ForInOfHeadEvaluation(uninitializedBoundNames, node.right, iterationKind);
-
     if (keyResult.Type !== "normal") {
       // When enumerate, if the target is nil, a break completion will be returned.
       return keyResult;
     }
-
     return ForInOfBodyEvaluation(lhs, node.body, keyResult.Value, iterationKind, lhsKind);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
   function ForInOfHeadEvaluation(uninitializedBoundNames, expr, iterationKind) {
     const runningContext = getRunningContext();
     const oldEnv = runningContext.LexicalEnvironment;
-
     if (uninitializedBoundNames.length > 0) {
       const newEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
-
       for (const name of uninitializedBoundNames) {
         newEnv.CreateMutableBinding(name, false);
       }
-
       runningContext.LexicalEnvironment = newEnv;
     }
-
     const exprRef = Evaluate(expr);
     runningContext.LexicalEnvironment = oldEnv;
     const exprValue = (0, _contextFree.GetValue)(exprRef);
-
     if (iterationKind === "enumerate") {
       if (exprValue === null || exprValue === undefined) {
         return new _ExecutionContext.CompletionRecord("break", _ExecutionContext.Empty);
       }
-
       const iterator = EnumerateObjectProperties(exprValue);
       return (0, _ExecutionContext.NormalCompletion)(iterator);
     }
-
     const iterator = (0, _contextFree.CreateListIteratorRecord)(exprValue);
     return (0, _ExecutionContext.NormalCompletion)(iterator);
   }
-
   function ForInOfBodyEvaluation(node, stmt, iteratorRecord, iterationKind, lhsKind) {
     const lhs = lhsKind === "assignment" ? node : node.declarations[0].id;
     const oldEnv = getRunningContext().LexicalEnvironment;
-    let V; // When `destructuring` is false,
+    let V;
+    // When `destructuring` is false,
     // For `node` whose `kind` is assignment:
     //   `lhs` is an `Identifier` or a `MemberExpression`,
     // Otherwise:
     //   `lhs` is an `Identifier`.
-
-    const destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern"; // eslint-disable-next-line no-constant-condition
-
+    const destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern";
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       const {
         done,
         value: nextValue
       } = iteratorRecord.next();
-
       if (done) {
         return (0, _ExecutionContext.NormalCompletion)(V);
       }
-
       let lhsRef;
       let iterationEnv;
-
       if (lhsKind === "lexicalBinding") {
         iterationEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
         (0, _contextFree.ForDeclarationBindingInstantiation)(node, iterationEnv);
         getRunningContext().LexicalEnvironment = iterationEnv;
-
         if (!destructuring) {
           const [lhsName] = (0, _traverse.collectBoundNames)(lhs);
           lhsRef = ResolveBinding(lhsName);
@@ -770,58 +641,49 @@ function cook(rootAst, codeSource, {
       } else if (!destructuring) {
         lhsRef = Evaluate(lhs).Value;
       }
-
       destructuring ? lhsKind === "assignment" ? DestructuringAssignmentEvaluation(lhs, nextValue) : lhsKind === "varBinding" ? BindingInitialization(lhs, nextValue, undefined) : BindingInitialization(lhs, nextValue, iterationEnv) : lhsKind === "lexicalBinding" ? (0, _contextFree.InitializeReferencedBinding)(lhsRef, nextValue) : (0, _contextFree.PutValue)(lhsRef, nextValue);
       const result = Evaluate(stmt);
       getRunningContext().LexicalEnvironment = oldEnv;
-
       if (!(0, _contextFree.LoopContinues)(result)) {
         const status = (0, _contextFree.UpdateEmpty)(result, V);
-
         if (!(iterationKind === "enumerate" || iteratorRecord.return === undefined)) {
           // Perform *IteratorClose*
           // https://tc39.es/ecma262/#sec-iteratorclose
           const innerResult = iteratorRecord.return();
-
           if (!innerResult || !["object", "function"].includes(typeof innerResult)) {
             throw new TypeError(`Iterator result is not an object`);
           }
         }
-
         return status;
       }
-
       if (result.Value !== _ExecutionContext.Empty) {
         V = result.Value;
       }
     }
-  } // https://tc39.es/ecma262/#sec-enumerate-object-properties
-
+  }
 
+  // https://tc39.es/ecma262/#sec-enumerate-object-properties
   function* EnumerateObjectProperties(value) {
     for (const key in value) {
       yield key;
     }
-  } // For statements.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-forloopevaluation
-
+  }
 
+  // For statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-forloopevaluation
   function ForLoopEvaluation(node) {
     var _node$init;
-
     if (((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) === "VariableDeclaration") {
       // `for (var … ; … ; … ) …`
       if (node.init.kind === "var") {
         Evaluate(node.init);
         return ForBodyEvaluation(node.test, node.update, node.body, []);
-      } // `for (let/const … ; … ; … ) …`
-
-
+      }
+      // `for (let/const … ; … ; … ) …`
       const oldEnv = getRunningContext().LexicalEnvironment;
       const loopEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
       const isConst = node.init.kind === "const";
       const boundNames = (0, _traverse.collectBoundNames)(node.init);
-
       for (const dn of boundNames) {
         if (isConst) {
           loopEnv.CreateImmutableBinding(dn, true);
@@ -829,113 +691,94 @@ function cook(rootAst, codeSource, {
           loopEnv.CreateMutableBinding(dn, false);
         }
       }
-
       getRunningContext().LexicalEnvironment = loopEnv;
       Evaluate(node.init);
       const perIterationLets = isConst ? [] : Array.from(boundNames);
       const bodyResult = ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
       getRunningContext().LexicalEnvironment = oldEnv;
       return bodyResult;
-    } // `for ( … ; … ; … ) …`
-
-
+    }
+    // `for ( … ; … ; … ) …`
     if (node.init) {
       const exprRef = Evaluate(node.init);
       (0, _contextFree.GetValue)(exprRef);
     }
-
     return ForBodyEvaluation(node.test, node.update, node.body, []);
-  } // https://tc39.es/ecma262/#sec-forbodyevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-forbodyevaluation
   function ForBodyEvaluation(test, increment, stmt, perIterationBindings) {
     CreatePerIterationEnvironment(perIterationBindings);
-    let V; // eslint-disable-next-line no-constant-condition
-
+    let V;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       if (test) {
         const testRef = Evaluate(test);
         const testValue = (0, _contextFree.GetValue)(testRef);
-
         if (!testValue) {
           return (0, _ExecutionContext.NormalCompletion)(V);
         }
       }
-
       const result = Evaluate(stmt);
-
       if (!(0, _contextFree.LoopContinues)(result)) {
         return (0, _contextFree.UpdateEmpty)(result, V);
       }
-
       if (result.Value) {
         V = result.Value;
       }
-
       CreatePerIterationEnvironment(perIterationBindings);
-
       if (increment) {
         const incRef = Evaluate(increment);
         (0, _contextFree.GetValue)(incRef);
       }
     }
-  } // https://tc39.es/ecma262/#sec-createperiterationenvironment
-
+  }
 
+  // https://tc39.es/ecma262/#sec-createperiterationenvironment
   function CreatePerIterationEnvironment(perIterationBindings) {
     if (perIterationBindings.length === 0) {
       return;
     }
-
     const lastIterationEnv = getRunningContext().LexicalEnvironment;
     const outer = lastIterationEnv.OuterEnv;
     const thisIterationEnv = new _ExecutionContext.DeclarativeEnvironment(outer);
-
     for (const bn of perIterationBindings) {
       thisIterationEnv.CreateMutableBinding(bn, false);
       const lastValue = lastIterationEnv.GetBindingValue(bn, false);
       thisIterationEnv.InitializeBinding(bn, lastValue);
     }
-
     getRunningContext().LexicalEnvironment = thisIterationEnv;
-  } // Destructuring assignments.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-destructuringassignmentevaluation
-
+  }
 
+  // Destructuring assignments.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-destructuringassignmentevaluation
   function DestructuringAssignmentEvaluation(pattern, value) {
     if (pattern.type === "ObjectPattern") {
       (0, _contextFree.RequireObjectCoercible)(value);
-
       if (pattern.properties.length > 0) {
         PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
       }
-
       return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
     }
-
     const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(value);
     return IteratorDestructuringAssignmentEvaluation(pattern.elements, iteratorRecord);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-propertydestructuringassignmentevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-propertydestructuringassignmentevaluation
   function PropertyDestructuringAssignmentEvaluation(properties, value) {
     const excludedNames = new Set();
-
     for (const prop of properties) {
       if (prop.type === "Property") {
         const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : EvaluateComputedPropertyName(prop.key);
         const valueTarget = prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value;
-
         if (valueTarget.type === "Identifier") {
           const lref = ResolveBinding(valueTarget.name);
           let v = (0, _contextFree.GetV)(value, propName);
-
           if (prop.value.type === "AssignmentPattern" && v === undefined) {
             // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
             const defaultValue = Evaluate(prop.value.right);
             v = (0, _contextFree.GetValue)(defaultValue);
           }
-
           (0, _contextFree.PutValue)(lref, v);
           excludedNames.add(propName);
         } else {
@@ -946,21 +789,18 @@ function cook(rootAst, codeSource, {
         RestDestructuringAssignmentEvaluation(prop, value, excludedNames);
       }
     }
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-keyeddestructuringassignmentevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-keyeddestructuringassignmentevaluation
   function KeyedDestructuringAssignmentEvaluation(node, value, propertyName) {
     const assignmentTarget = node.type === "AssignmentPattern" ? node.left : node;
     const isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
     let lref;
-
     if (!isObjectOrArray) {
       lref = Evaluate(assignmentTarget).Value;
     }
-
     const v = (0, _contextFree.GetV)(value, propertyName);
     let rhsValue;
-
     if (node.type === "AssignmentPattern" && v === undefined) {
       // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
       const defaultValue = Evaluate(node.right);
@@ -968,49 +808,41 @@ function cook(rootAst, codeSource, {
     } else {
       rhsValue = v;
     }
-
     if (isObjectOrArray) {
       return DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
     }
-
     return (0, _contextFree.PutValue)(lref, rhsValue);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
   function RestDestructuringAssignmentEvaluation(restProperty, value, excludedNames) {
     const lref = Evaluate(restProperty.argument).Value;
     const restObj = (0, _contextFree.CopyDataProperties)({}, value, excludedNames);
     return (0, _contextFree.PutValue)(lref, restObj);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
   function IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
     let status = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
-
     for (const element of elements) {
       if (!element) {
         iteratorRecord.next();
         status = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
         continue;
       }
-
       const assignmentTarget = element.type === "RestElement" ? element.argument : element.type === "AssignmentPattern" ? element.left : element;
       const isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
       let lref;
-
       if (!isObjectOrArray) {
         lref = Evaluate(assignmentTarget).Value;
       }
-
       let v;
-
       if (element.type !== "RestElement") {
         const {
           done,
           value: nextValue
         } = iteratorRecord.next();
         const value = done ? undefined : nextValue;
-
         if (element.type === "AssignmentPattern" && value === undefined) {
           // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
           const defaultValue = Evaluate(element.right);
@@ -1021,59 +853,53 @@ function cook(rootAst, codeSource, {
       } else {
         // RestElement
         v = [];
-        let n = 0; // eslint-disable-next-line no-constant-condition
-
+        let n = 0;
+        // eslint-disable-next-line no-constant-condition
         while (true) {
           const {
             done,
             value: nextValue
           } = iteratorRecord.next();
-
           if (done) {
             break;
           }
-
           v[n] = nextValue;
           n++;
         }
       }
-
       if (isObjectOrArray) {
         status = DestructuringAssignmentEvaluation(assignmentTarget, v);
       } else {
         status = (0, _contextFree.PutValue)(lref, v);
       }
     }
-
     return status;
-  } // Object expressions.
-  // https://tc39.es/ecma262/#sec-evaluate-property-access-with-expression-key
-
+  }
 
+  // Object expressions.
+  // https://tc39.es/ecma262/#sec-evaluate-property-access-with-expression-key
   function EvaluatePropertyAccessWithExpressionKey(baseValue, expression, strict) {
     const propertyNameReference = Evaluate(expression);
     const propertyNameValue = (0, _contextFree.GetValue)(propertyNameReference);
     const propertyKey = (0, _contextFree.ToPropertyKey)(propertyNameValue);
     return new _ExecutionContext.ReferenceRecord(baseValue, propertyKey, strict);
-  } // https://tc39.es/ecma262/#sec-evaluate-property-access-with-identifier-key
-
+  }
 
+  // https://tc39.es/ecma262/#sec-evaluate-property-access-with-identifier-key
   function EvaluatePropertyAccessWithIdentifierKey(baseValue, identifier, strict) {
     const propertyNameString = identifier.name;
     return new _ExecutionContext.ReferenceRecord(baseValue, propertyNameString, strict);
-  } // Block statements.
-  // https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
-
+  }
 
+  // Block statements.
+  // https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
   function BlockDeclarationInstantiation(code, env) {
     const declarations = (0, _traverse.collectScopedDeclarations)(code, {
       var: false,
       topLevel: false
     });
-
     for (const d of declarations) {
       const IsConstantDeclaration = d.type === "VariableDeclaration" && d.kind === "const";
-
       for (const dn of (0, _traverse.collectBoundNames)(d)) {
         if (IsConstantDeclaration) {
           env.CreateImmutableBinding(dn, true);
@@ -1081,61 +907,52 @@ function cook(rootAst, codeSource, {
           env.CreateMutableBinding(dn, false);
         }
       }
-
       if (d.type === "FunctionDeclaration") {
         const [fn] = (0, _traverse.collectBoundNames)(d);
         const fo = InstantiateFunctionObject(d, env);
         env.InitializeBinding(fn, fo);
       }
     }
-  } // Function declarations and expressions.
-  // https://tc39.es/ecma262/#sec-evaluatecall
-
+  }
 
+  // Function declarations and expressions.
+  // https://tc39.es/ecma262/#sec-evaluatecall
   function EvaluateCall(func, ref, args, callee) {
     let thisValue;
-
     if (ref instanceof _ExecutionContext.ReferenceRecord) {
       if ((0, _contextFree.IsPropertyReference)(ref)) {
         thisValue = ref.Base;
       }
     }
-
     const argList = ArgumentListEvaluation(args);
-
     if (typeof func !== "function") {
       const funcName = codeSource.substring(callee.start, callee.end);
       throw new TypeError(`${funcName} is not a function`);
     }
-
     const result = func.apply(thisValue, argList);
     (0, _sanitize.sanitize)(result);
     return (0, _ExecutionContext.NormalCompletion)(result);
-  } // https://tc39.es/ecma262/#sec-evaluatenew
-
+  }
 
+  // https://tc39.es/ecma262/#sec-evaluatenew
   function EvaluateNew(constructExpr, args) {
     const ref = Evaluate(constructExpr);
     const constructor = (0, _contextFree.GetValue)(ref);
     const argList = ArgumentListEvaluation(args);
-
     if (typeof constructor !== "function" || constructor[_ExecutionContext.IsConstructor] === false) {
       const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError(`${constructorName} is not a constructor`);
     }
-
     if (!(0, _sanitize.isAllowedConstructor)(constructor)) {
       const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError(`${constructorName} is not an allowed constructor`);
     }
-
     return (0, _ExecutionContext.NormalCompletion)(new constructor(...argList));
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
   function ArgumentListEvaluation(args) {
     const array = [];
-
     if (Array.isArray(args)) {
       for (const arg of args) {
         if (arg.type === "SpreadElement") {
@@ -1147,32 +964,27 @@ function cook(rootAst, codeSource, {
       }
     } else {
       array.push(GetTemplateObject(args));
-
       for (const expr of args.expressions) {
         array.push((0, _contextFree.GetValue)(Evaluate(expr)));
       }
     }
-
     return array;
-  } // https://tc39.es/ecma262/#sec-ecmascript-function-objects-call-thisargument-argumentslist
-
+  }
 
+  // https://tc39.es/ecma262/#sec-ecmascript-function-objects-call-thisargument-argumentslist
   function CallFunction(closure, args) {
     var _hooks$beforeCall;
-
     (_hooks$beforeCall = hooks.beforeCall) === null || _hooks$beforeCall === void 0 ? void 0 : _hooks$beforeCall.call(hooks, closure[_ExecutionContext.SourceNode]);
     PrepareForOrdinaryCall(closure);
     const result = OrdinaryCallEvaluateBody(closure, args);
     executionContextStack.pop();
-
     if (result.Type === "return") {
       return result.Value;
     }
-
     return undefined;
-  } // https://tc39.es/ecma262/#sec-prepareforordinarycall
-
+  }
 
+  // https://tc39.es/ecma262/#sec-prepareforordinarycall
   function PrepareForOrdinaryCall(F) {
     const calleeContext = new _ExecutionContext.ExecutionContext();
     calleeContext.Function = F;
@@ -1181,42 +993,36 @@ function cook(rootAst, codeSource, {
     calleeContext.LexicalEnvironment = localEnv;
     executionContextStack.push(calleeContext);
     return calleeContext;
-  } // https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
-
+  }
 
+  // https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
   function OrdinaryCallEvaluateBody(F, args) {
     return EvaluateFunctionBody(F[_ExecutionContext.ECMAScriptCode], F, args);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody
   function EvaluateFunctionBody(body, F, args) {
     FunctionDeclarationInstantiation(F, args);
-
     if (Array.isArray(body)) {
       return EvaluateStatementList(body);
     }
-
     return new _ExecutionContext.CompletionRecord("return", (0, _contextFree.GetValue)(Evaluate(body)));
-  } // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
   function EvaluateStatementList(statements) {
     let result = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
-
     for (const stmt of statements) {
       const s = Evaluate(stmt);
-
       if (s.Type !== "normal") {
         return s;
       }
-
       result = (0, _contextFree.UpdateEmpty)(result, s.Value);
     }
-
     return result;
-  } // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
   function FunctionDeclarationInstantiation(func, args) {
     const calleeContext = getRunningContext();
     const code = func[_ExecutionContext.ECMAScriptCode];
@@ -1227,19 +1033,17 @@ function cook(rootAst, codeSource, {
       var: true,
       topLevel: true
     });
-    const varNames = (0, _traverse.collectBoundNames)(varDeclarations); // `functionNames` ∈ `varNames`
-    // `functionsToInitialize` ≈ `functionNames`
+    const varNames = (0, _traverse.collectBoundNames)(varDeclarations);
 
+    // `functionNames` ∈ `varNames`
+    // `functionsToInitialize` ≈ `functionNames`
     const functionNames = [];
     const functionsToInitialize = [];
-
     for (let i = varDeclarations.length - 1; i >= 0; i--) {
       const d = varDeclarations[i];
-
       if (d.type === "FunctionDeclaration") {
         ThrowIfFunctionIsInvalid(d);
         const [fn] = (0, _traverse.collectBoundNames)(d);
-
         if (!functionNames.includes(fn)) {
           functionNames.unshift(fn);
           functionsToInitialize.unshift(d);
@@ -1248,18 +1052,14 @@ function cook(rootAst, codeSource, {
         throw new SyntaxError("Var declaration is not recommended, use `let` or `const` instead");
       }
     }
-
     const env = calleeContext.LexicalEnvironment;
-
     for (const paramName of parameterNames) {
       // In strict mode, it's guaranteed no duplicate params exist.
       env.CreateMutableBinding(paramName, false);
     }
-
     const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(args);
     IteratorBindingInitialization(formals, iteratorRecord, env);
     let varEnv;
-
     if (!hasParameterExpressions) {
       // NOTE: Only a single Environment Record is needed for the parameters
       // and top-level vars.
@@ -1270,24 +1070,22 @@ function cook(rootAst, codeSource, {
           env.InitializeBinding(n, undefined);
         }
       }
-
       varEnv = env;
     } else {
       // NOTE: A separate Environment Record is needed to ensure that closures
       // created by expressions in the formal parameter list do not have
       // visibility of declarations in the function body.
       varEnv = new _ExecutionContext.DeclarativeEnvironment(env);
-      calleeContext.VariableEnvironment = varEnv; // `varNames` are unique.
-
+      calleeContext.VariableEnvironment = varEnv;
+      // `varNames` are unique.
       for (const n of varNames) {
         varEnv.CreateMutableBinding(n, false);
         let initialValue;
-
         if (parameterNames.includes(n) && !functionNames.includes(n)) {
           initialValue = env.GetBindingValue(n, false);
         }
-
-        varEnv.InitializeBinding(n, initialValue); // NOTE: A var with the same name as a formal parameter initially has
+        varEnv.InitializeBinding(n, initialValue);
+        // NOTE: A var with the same name as a formal parameter initially has
         // the same value as the corresponding initialized parameter.
       }
     }
@@ -1298,7 +1096,6 @@ function cook(rootAst, codeSource, {
       var: false,
       topLevel: true
     });
-
     for (const d of lexDeclarations) {
       for (const dn of (0, _traverse.collectBoundNames)(d)) {
         // Only lexical VariableDeclaration here in top-level.
@@ -1309,23 +1106,21 @@ function cook(rootAst, codeSource, {
         }
       }
     }
-
     for (const f of functionsToInitialize) {
       const [fn] = (0, _traverse.collectBoundNames)(f);
       const fo = InstantiateFunctionObject(f, lexEnv);
       varEnv.SetMutableBinding(fn, fo, false);
     }
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatefunctionobject
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatefunctionobject
   function InstantiateFunctionObject(func, scope) {
     return OrdinaryFunctionCreate(func, scope, true);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
   function InstantiateOrdinaryFunctionExpression(functionExpression) {
     const scope = getRunningContext().LexicalEnvironment;
-
     if (functionExpression.id) {
       const name = functionExpression.id.name;
       const funcEnv = new _ExecutionContext.DeclarativeEnvironment(scope);
@@ -1337,22 +1132,21 @@ function cook(rootAst, codeSource, {
       const closure = OrdinaryFunctionCreate(functionExpression, scope, true);
       return closure;
     }
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression
   function InstantiateArrowFunctionExpression(arrowFunction) {
     const scope = getRunningContext().LexicalEnvironment;
     const closure = OrdinaryFunctionCreate(arrowFunction, scope, false);
     return closure;
-  } // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
-
+  }
 
+  // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
   function OrdinaryFunctionCreate(sourceNode, scope, isConstructor) {
     const F = function () {
       // eslint-disable-next-line prefer-rest-params
       return CallFunction(F, arguments);
     };
-
     Object.defineProperties(F, {
       [_ExecutionContext.SourceNode]: {
         value: sourceNode
@@ -1371,36 +1165,32 @@ function cook(rootAst, codeSource, {
       }
     });
     return F;
-  } // Patterns initialization.
-  // https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
-
+  }
 
+  // Patterns initialization.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
   function BindingInitialization(node, value, environment) {
     switch (node.type) {
       case "Identifier":
         return InitializeBoundName(node.name, value, environment);
-
       case "ObjectPattern":
         (0, _contextFree.RequireObjectCoercible)(value);
         return PropertyBindingInitialization(node.properties, value, environment);
-
       case "ArrayPattern":
         {
           const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(value);
           return IteratorBindingInitialization(node.elements, iteratorRecord, environment);
         }
     }
-  } // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-propertybindinginitialization
-
+  }
 
+  // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-propertybindinginitialization
   function PropertyBindingInitialization(properties, value, environment) {
     const excludedNames = new Set();
-
     for (const prop of properties) {
       if (prop.type === "RestElement") {
         return RestBindingInitialization(prop, value, environment, excludedNames);
       }
-
       if (!prop.computed && prop.key.type === "Identifier") {
         KeyedBindingInitialization(prop.value, value, environment, prop.key.name);
         excludedNames.add(prop.key.name);
@@ -1410,36 +1200,31 @@ function cook(rootAst, codeSource, {
         excludedNames.add(P);
       }
     }
-
     return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
-  } // https://tc39.es/ecma262/#prod-ComputedPropertyName
-
+  }
 
+  // https://tc39.es/ecma262/#prod-ComputedPropertyName
   function EvaluateComputedPropertyName(node) {
     const propName = (0, _contextFree.GetValue)(Evaluate(node));
     return (0, _contextFree.ToPropertyKey)(propName);
-  } // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-restbindinginitialization
-
+  }
 
+  // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-restbindinginitialization
   function RestBindingInitialization(restProperty, value, environment, excludedNames) {
     const lhs = ResolveBinding(restProperty.argument.name, environment);
     const restObj = (0, _contextFree.CopyDataProperties)({}, value, excludedNames);
-
     if (!environment) {
       return (0, _contextFree.PutValue)(lhs, restObj);
     }
-
     return (0, _contextFree.InitializeReferencedBinding)(lhs, restObj);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-iteratorbindinginitialization
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-iteratorbindinginitialization
   function IteratorBindingInitialization(elements, iteratorRecord, environment) {
     if (elements.length === 0) {
       return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
     }
-
     let result;
-
     for (const node of elements) {
       if (!node) {
         // Elision element.
@@ -1450,37 +1235,33 @@ function cook(rootAst, codeSource, {
         if (node.argument.type === "Identifier") {
           const lhs = ResolveBinding(node.argument.name, environment);
           const A = [];
-          let n = 0; // eslint-disable-next-line no-constant-condition
-
+          let n = 0;
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             const {
               done,
               value
             } = iteratorRecord.next();
-
             if (done) {
               result = environment ? (0, _contextFree.InitializeReferencedBinding)(lhs, A) : (0, _contextFree.PutValue)(lhs, A);
               break;
             }
-
             A[n] = value;
             n++;
           }
         } else {
           const A = [];
-          let n = 0; // eslint-disable-next-line no-constant-condition
-
+          let n = 0;
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             const {
               done,
               value
             } = iteratorRecord.next();
-
             if (done) {
               result = BindingInitialization(node.argument, A, environment);
               break;
             }
-
             A[n] = value;
             n++;
           }
@@ -1488,7 +1269,6 @@ function cook(rootAst, codeSource, {
       } else {
         // Normal element.
         const bindingElement = node.type === "AssignmentPattern" ? node.left : node;
-
         switch (bindingElement.type) {
           case "ObjectPattern":
           case "ArrayPattern":
@@ -1498,20 +1278,16 @@ function cook(rootAst, codeSource, {
                 done,
                 value
               } = iteratorRecord.next();
-
               if (!done) {
                 v = value;
               }
-
               if (node.type === "AssignmentPattern" && v === undefined) {
                 const defaultValue = Evaluate(node.right);
                 v = (0, _contextFree.GetValue)(defaultValue);
               }
-
               result = BindingInitialization(bindingElement, v, environment);
               break;
             }
-
           case "Identifier":
             {
               const bindingId = bindingElement.name;
@@ -1521,84 +1297,69 @@ function cook(rootAst, codeSource, {
                 done,
                 value
               } = iteratorRecord.next();
-
               if (!done) {
                 v = value;
               }
-
               if (node.type === "AssignmentPattern" && v === undefined) {
                 // IsAnonymousFunctionDefinition(Initializer)
                 const defaultValue = Evaluate(node.right);
                 v = (0, _contextFree.GetValue)(defaultValue);
               }
-
               result = environment ? (0, _contextFree.InitializeReferencedBinding)(lhs, v) : (0, _contextFree.PutValue)(lhs, v);
               break;
             }
         }
       }
     }
-
     return result;
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-keyedbindinginitialization
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-keyedbindinginitialization
   function KeyedBindingInitialization(node, value, environment, propertyName) {
     const isIdentifier = node.type === "Identifier" || node.type === "AssignmentPattern" && node.left.type === "Identifier";
-
     if (isIdentifier) {
       const bindingId = node.type === "Identifier" ? node.name : node.left.name;
       const lhs = ResolveBinding(bindingId, environment);
       let v = (0, _contextFree.GetV)(value, propertyName);
-
       if (node.type === "AssignmentPattern" && v === undefined) {
         // If IsAnonymousFunctionDefinition(Initializer)
         const defaultValue = Evaluate(node.right);
         v = (0, _contextFree.GetValue)(defaultValue);
       }
-
       if (!environment) {
         return (0, _contextFree.PutValue)(lhs, v);
       }
-
       return (0, _contextFree.InitializeReferencedBinding)(lhs, v);
     }
-
     let v = (0, _contextFree.GetV)(value, propertyName);
-
     if (node.type === "AssignmentPattern" && v === undefined) {
       const defaultValue = Evaluate(node.right);
       v = (0, _contextFree.GetValue)(defaultValue);
     }
-
     return BindingInitialization(node.type === "AssignmentPattern" ? node.left : node, v, environment);
-  } // https://tc39.es/ecma262/#sec-initializeboundname
-
+  }
 
+  // https://tc39.es/ecma262/#sec-initializeboundname
   function InitializeBoundName(name, value, environment) {
     // Assert: environment is always present.
     environment.InitializeBinding(name, value);
     return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
   }
-
   function ThrowIfFunctionIsInvalid(func) {
     if (func.async || func.generator) {
       throw new SyntaxError(`${func.async ? "Async" : "Generator"} function is not allowed`);
     }
-
     if (expressionOnly && !func.expression) {
       throw new SyntaxError("Only an `Expression` is allowed in `ArrowFunctionExpression`'s body");
     }
   }
-
   if (expressionOnly) {
     return (0, _contextFree.GetValue)(Evaluate(rootAst));
   }
-
   (_hooks$beforeEvaluate3 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate3 === void 0 ? void 0 : _hooks$beforeEvaluate3.call(hooks, rootAst);
   ThrowIfFunctionIsInvalid(rootAst);
-  const [fn] = (0, _traverse.collectBoundNames)(rootAst); // Create an immutable binding for the root function.
-
+  const [fn] = (0, _traverse.collectBoundNames)(rootAst);
+  // Create an immutable binding for the root function.
   rootEnv.CreateImmutableBinding(fn, true);
   const fo = InstantiateFunctionObject(rootAst, rootEnv);
   rootEnv.InitializeBinding(fn, fo);