@next-core/cook 1.6.77 → 1.6.79

package/dist/esm/cook.js

@@ -2,11 +2,9 @@ import { ApplyStringOrNumericAssignment, CreateListIteratorRecord, ApplyStringOr
 import { CompletionRecord, DeclarativeEnvironment, ECMAScriptCode, Empty, Environment, ExecutionContext, FormalParameters, FunctionEnvironment, IsConstructor, NormalCompletion, ReferenceRecord, SourceNode } from "./ExecutionContext";
 import { sanitize, isAllowedConstructor } from "./sanitize";
 import { collectBoundNames, collectScopedDeclarations, containsExpression } from "./traverse";
-
 /** For next-core internal usage only. */
 export function cook(rootAst, codeSource) {
   var _hooks$beforeEvaluate3;
-
   var {
     rules,
     globalVariables = {},
@@ -18,21 +16,18 @@ export function cook(rootAst, codeSource) {
   rootContext.VariableEnvironment = rootEnv;
   rootContext.LexicalEnvironment = rootEnv;
   var executionContextStack = [rootContext];
-
   for (var [key, value] of Object.entries(globalVariables)) {
     rootEnv.CreateImmutableBinding(key, true);
     rootEnv.InitializeBinding(key, value);
   }
+  var TemplateMap = new WeakMap();
 
-  var TemplateMap = new WeakMap(); // https://tc39.es/ecma262/#sec-gettemplateobject
-
+  // https://tc39.es/ecma262/#sec-gettemplateobject
   function GetTemplateObject(templateLiteral) {
     var memo = TemplateMap.get(templateLiteral);
-
     if (memo) {
       return memo;
     }
-
     var rawObj = templateLiteral.quasis.map(quasi => quasi.value.raw);
     var template = templateLiteral.quasis.map(quasi => quasi.value.cooked);
     Object.freeze(rawObj);
@@ -46,18 +41,15 @@ export 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
           var array = [];
-
           for (var element of node.elements) {
             if (!element) {
               array.length += 1;
@@ -68,10 +60,8 @@ export function cook(rootAst, codeSource) {
               array.push(GetValue(Evaluate(element)));
             }
           }
-
           return NormalCompletion(array);
         }
-
       case "ArrowFunctionExpression":
         {
           // https://tc39.es/ecma262/#sec-arrow-function-definitions
@@ -79,14 +69,12 @@ export function cook(rootAst, codeSource) {
           var closure = InstantiateArrowFunctionExpression(node);
           return NormalCompletion(closure);
         }
-
       case "BinaryExpression":
         {
           var leftRef = Evaluate(node.left);
           var leftValue = GetValue(leftRef);
           var rightRef = Evaluate(node.right).Value;
           var rightValue = GetValue(rightRef);
-
           if (expressionOnly && node.operator === "|>") {
             // Minimal pipeline operator is supported only in expression-only mode.
             // See https://tc39.es/proposal-pipeline-operator
@@ -95,50 +83,39 @@ export function cook(rootAst, codeSource) {
               var funcName = codeSource.substring(node.right.start, node.right.end);
               throw new TypeError("".concat(funcName, " is not a function"));
             }
-
             var thisValue;
-
             if (rightRef instanceof ReferenceRecord) {
               if (IsPropertyReference(rightRef)) {
                 thisValue = rightRef.Base;
               }
             }
-
             return NormalCompletion(rightValue.call(thisValue, leftValue));
-          } // https://tc39.es/ecma262/#sec-additive-operators
-
-
+          }
+          // https://tc39.es/ecma262/#sec-additive-operators
           var result = ApplyStringOrNumericBinaryOperator(leftValue, node.operator, rightValue);
           return NormalCompletion(result);
         }
-
       case "CallExpression":
         {
           // https://tc39.es/ecma262/#sec-function-calls
           var ref = Evaluate(node.callee, optionalChainRef).Value;
           var func = GetValue(ref);
-
           if ((func === undefined || func === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return NormalCompletion(undefined);
           }
-
           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 NormalCompletion(GetValue(Evaluate(GetValue(Evaluate(node.test)) ? node.consequent : node.alternate)));
-
       case "Identifier":
         // https://tc39.es/ecma262/#sec-identifiers
         return NormalCompletion(ResolveBinding(node.name));
-
       case "Literal":
         {
           // https://tc39.es/ecma262/#sec-primary-expression-literals
@@ -147,67 +124,52 @@ export function cook(rootAst, codeSource) {
               // Invalid regular expression fails silently in @babel/parser.
               throw new SyntaxError("Invalid regular expression: ".concat(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: ".concat(node.raw));
             }
           }
-
           return NormalCompletion(node.value);
         }
-
       case "LogicalExpression":
         {
           // https://tc39.es/ecma262/#sec-binary-logical-operators
           var _leftValue = GetValue(Evaluate(node.left));
-
           switch (node.operator) {
             case "&&":
               return NormalCompletion(_leftValue && GetValue(Evaluate(node.right)));
-
             case "||":
               return NormalCompletion(_leftValue || GetValue(Evaluate(node.right)));
-
             case "??":
               return NormalCompletion(_leftValue !== null && _leftValue !== void 0 ? _leftValue : GetValue(Evaluate(node.right)));
             // istanbul ignore next
-
             default:
               throw new SyntaxError( // eslint-disable-next-line @typescript-eslint/ban-ts-comment
               // @ts-ignore never reach here.
               "Unsupported logical operator '".concat(node.operator, "'"));
           }
         }
-
       case "MemberExpression":
         {
           // https://tc39.es/ecma262/#sec-property-accessors
           var baseReference = Evaluate(node.object, optionalChainRef).Value;
           var baseValue = GetValue(baseReference);
-
           if ((baseValue === undefined || baseValue === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return NormalCompletion(undefined);
           }
-
           sanitize(baseValue);
-
           var _result = node.computed ? EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
-
           sanitize(_result);
           return 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
           var object = {};
-
           for (var prop of node.properties) {
             if (prop.type === "SpreadElement") {
               var fromValue = GetValue(Evaluate(prop.argument));
@@ -216,47 +178,36 @@ export function cook(rootAst, codeSource) {
               if (prop.kind !== "init") {
                 throw new SyntaxError("Unsupported object getter/setter");
               }
-
               var 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] = GetValue(Evaluate(prop.value));
             }
           }
-
           return NormalCompletion(object);
         }
-
       case "SequenceExpression":
         {
           // https://tc39.es/ecma262/#sec-comma-operator
           var _result2;
-
           for (var expr of node.expressions) {
             _result2 = NormalCompletion(GetValue(Evaluate(expr)));
           }
-
           return _result2;
         }
-
       case "TemplateLiteral":
         {
           // https://tc39.es/ecma262/#sec-template-literals
           var chunks = [node.quasis[0].value.cooked];
           var index = 0;
-
           for (var _expr of node.expressions) {
             var val = GetValue(Evaluate(_expr));
             chunks.push(String(val));
             chunks.push(node.quasis[index += 1].value.cooked);
           }
-
           return NormalCompletion(chunks.join(""));
         }
-
       case "TaggedTemplateExpression":
         {
           // https://tc39.es/ecma262/#sec-tagged-templates
@@ -265,38 +216,32 @@ export function cook(rootAst, codeSource) {
           sanitize(tagFunc);
           return EvaluateCall(tagFunc, tagRef, node.quasi, node.tag);
         }
-
       case "UnaryExpression":
         {
           // https://tc39.es/ecma262/#sec-unary-operators
           var _ref = Evaluate(node.argument).Value;
-
           if (!expressionOnly && node.operator === "delete") {
             // Delete operator is supported only in function mode.
             if (!(_ref instanceof ReferenceRecord)) {
               return NormalCompletion(true);
-            } // istanbul ignore else
-
-
+            }
+            // istanbul ignore else
             if (IsPropertyReference(_ref)) {
               var deleteStatus = delete _ref.Base[_ref.ReferenceName];
               return NormalCompletion(deleteStatus);
-            } // Should never reach here in strict mode.
-
+            }
+            // Should never reach here in strict mode.
           }
 
           if (node.operator === "typeof") {
             if (_ref instanceof ReferenceRecord && _ref.Base === "unresolvable") {
               return NormalCompletion("undefined");
             }
-
             return NormalCompletion(typeof GetValue(_ref));
           }
-
           return NormalCompletion(ApplyUnaryOperator(GetValue(_ref), node.operator));
         }
     }
-
     if (!expressionOnly) {
       // Statements and assignments:
       switch (node.type) {
@@ -305,25 +250,19 @@ export function cook(rootAst, codeSource) {
             // https://tc39.es/ecma262/#sec-assignment-operators
             if (node.operator === "=") {
               if (!(node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern")) {
-                var _lref = Evaluate(node.left).Value; // Todo: IsAnonymousFunctionDefinition(lref)
-
+                var _lref = Evaluate(node.left).Value;
+                // Todo: IsAnonymousFunctionDefinition(lref)
                 var _rref2 = Evaluate(node.right);
-
                 var _rval2 = GetValue(_rref2);
-
                 PutValue(_lref, _rval2);
                 return NormalCompletion(_rval2);
               }
-
               var _rref = Evaluate(node.right);
-
               var _rval = GetValue(_rref);
-
               DestructuringAssignmentEvaluation(node.left, _rval);
               return NormalCompletion(_rval);
-            } // Operators other than `=`.
-
-
+            }
+            // Operators other than `=`.
             var lref = Evaluate(node.left).Value;
             var lval = GetValue(lref);
             var rref = Evaluate(node.right);
@@ -332,14 +271,12 @@ export function cook(rootAst, codeSource) {
             PutValue(lref, r);
             return NormalCompletion(r);
           }
-
         case "BlockStatement":
           {
             // https://tc39.es/ecma262/#sec-block
             if (!node.body.length) {
               return NormalCompletion(Empty);
             }
-
             var oldEnv = getRunningContext().LexicalEnvironment;
             var blockEnv = new DeclarativeEnvironment(oldEnv);
             BlockDeclarationInstantiation(node.body, blockEnv);
@@ -348,67 +285,52 @@ export function cook(rootAst, codeSource) {
             getRunningContext().LexicalEnvironment = oldEnv;
             return blockValue;
           }
-
         case "BreakStatement":
           // https://tc39.es/ecma262/#sec-break-statement
           return new CompletionRecord("break", Empty);
-
         case "ContinueStatement":
           // https://tc39.es/ecma262/#sec-continue-statement
           return new CompletionRecord("continue", Empty);
-
         case "EmptyStatement":
           // https://tc39.es/ecma262/#sec-empty-statement
           return NormalCompletion(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 NormalCompletion(Empty);
-
         case "FunctionExpression":
           // https://tc39.es/ecma262/#sec-function-defining-expressions
           ThrowIfFunctionIsInvalid(node);
           return NormalCompletion(InstantiateOrdinaryFunctionExpression(node));
-
         case "IfStatement":
           // https://tc39.es/ecma262/#sec-if-statement
           return GetValue(Evaluate(node.test)) ? ((_hooks$beforeBranch = hooks.beforeBranch) !== null && _hooks$beforeBranch !== void 0 && _hooks$beforeBranch.call(hooks, node, "if"), UpdateEmpty(Evaluate(node.consequent), undefined)) : ((_hooks$beforeBranch2 = hooks.beforeBranch) !== null && _hooks$beforeBranch2 !== void 0 && _hooks$beforeBranch2.call(hooks, node, "else"), node.alternate) ? UpdateEmpty(Evaluate(node.alternate), undefined) : NormalCompletion(undefined);
-
         case "ReturnStatement":
           {
             // https://tc39.es/ecma262/#sec-return-statement
             var v;
-
             if (node.argument) {
               var exprRef = Evaluate(node.argument);
               v = GetValue(exprRef);
             }
-
             return new CompletionRecord("return", v);
           }
-
         case "ThrowStatement":
           // https://tc39.es/ecma262/#sec-throw-statement
           throw GetValue(Evaluate(node.argument));
-
         case "UpdateExpression":
           {
             // https://tc39.es/ecma262/#sec-update-expressions
@@ -418,38 +340,30 @@ export function cook(rootAst, codeSource) {
             PutValue(lhs, newValue);
             return NormalCompletion(node.prefix ? newValue : oldValue);
           }
-
         case "SwitchCase":
           return EvaluateStatementList(node.consequent);
-
         case "SwitchStatement":
           {
             // https://tc39.es/ecma262/#sec-switch-statement
             var _exprRef = Evaluate(node.discriminant);
-
             var switchValue = GetValue(_exprRef);
             var _oldEnv = getRunningContext().LexicalEnvironment;
-
             var _blockEnv = new DeclarativeEnvironment(_oldEnv);
-
             BlockDeclarationInstantiation(node.cases, _blockEnv);
             getRunningContext().LexicalEnvironment = _blockEnv;
             var R = CaseBlockEvaluation(node.cases, switchValue);
             getRunningContext().LexicalEnvironment = _oldEnv;
             return EvaluateBreakableStatement(R);
           }
-
         case "TryStatement":
           {
             // https://tc39.es/ecma262/#sec-try-statement
             var _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 +372,17 @@ export function cook(rootAst, codeSource) {
             } finally {
               if (node.finalizer) {
                 var F = Evaluate(node.finalizer);
-
                 if (F.Type !== "normal") {
                   _R = F;
                 }
               }
             }
-
             return _R;
           }
-
         case "VariableDeclaration":
           {
             // https://tc39.es/ecma262/#sec-declarations-and-the-variable-statement
             var _result3;
-
             for (var declarator of node.declarations) {
               if (!declarator.init) {
                 // Assert: a declarator without init is always an identifier.
@@ -480,219 +390,181 @@ export function cook(rootAst, codeSource) {
                   _result3 = NormalCompletion(Empty);
                 } else {
                   var _lhs = ResolveBinding(declarator.id.name);
-
                   _result3 = InitializeReferencedBinding(_lhs, undefined);
                 }
               } else if (declarator.id.type === "Identifier") {
                 var bindingId = declarator.id.name;
-
-                var _lhs2 = ResolveBinding(bindingId); // Todo: IsAnonymousFunctionDefinition(Initializer)
-
-
+                var _lhs2 = ResolveBinding(bindingId);
+                // Todo: IsAnonymousFunctionDefinition(Initializer)
                 var rhs = Evaluate(declarator.init);
-
                 var _value = GetValue(rhs);
-
                 _result3 = node.kind === "var" ? PutValue(_lhs2, _value) : InitializeReferencedBinding(_lhs2, _value);
               } else {
                 var _rhs = Evaluate(declarator.init);
-
                 var _rval3 = GetValue(_rhs);
-
                 _result3 = BindingInitialization(declarator.id, _rval3, node.kind === "var" ? undefined : getRunningContext().LexicalEnvironment);
               }
             }
-
             return _result3;
           }
-
         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 `".concat(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 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) {
     var oldEnv = getRunningContext().LexicalEnvironment;
     var catchEnv = new DeclarativeEnvironment(oldEnv);
-
     for (var argName of collectBoundNames(node.param)) {
       catchEnv.CreateMutableBinding(argName, false);
     }
-
     getRunningContext().LexicalEnvironment = catchEnv;
     BindingInitialization(node.param, thrownValue, catchEnv);
     var 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 === Empty ? NormalCompletion(undefined) : 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) {
     var V;
     var defaultCaseIndex = cases.findIndex(switchCase => !switchCase.test);
     var hasDefaultCase = defaultCaseIndex >= 0;
     var A = hasDefaultCase ? cases.slice(0, defaultCaseIndex) : cases;
     var found = false;
-
     for (var C of A) {
       if (!found) {
         found = CaseClauseIsSelected(C, input);
       }
-
       if (found) {
         var _R2 = Evaluate(C);
-
         if (_R2.Value !== Empty) {
           V = _R2.Value;
         }
-
         if (_R2.Type !== "normal") {
           return UpdateEmpty(_R2, V);
         }
       }
     }
-
     if (!hasDefaultCase) {
       return NormalCompletion(V);
     }
-
     var foundInB = false;
     var B = cases.slice(defaultCaseIndex + 1);
-
     if (!found) {
       for (var _C of B) {
         if (!foundInB) {
           foundInB = CaseClauseIsSelected(_C, input);
         }
-
         if (foundInB) {
           var _R3 = Evaluate(_C);
-
           if (_R3.Value !== Empty) {
             V = _R3.Value;
           }
-
           if (_R3.Type !== "normal") {
             return UpdateEmpty(_R3, V);
           }
         }
       }
     }
-
     if (foundInB) {
       return NormalCompletion(V);
     }
-
     var R = Evaluate(cases[defaultCaseIndex]);
-
     if (R.Value !== Empty) {
       V = R.Value;
     }
-
     if (R.Type !== "normal") {
       return 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 (var _C2 of B) {
       var _R4 = Evaluate(_C2);
-
       if (_R4.Value !== Empty) {
         V = _R4.Value;
       }
-
       if (_R4.Type !== "normal") {
         return UpdateEmpty(_R4, V);
       }
     }
-
     return NormalCompletion(V);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
   function CaseClauseIsSelected(C, input) {
     var clauseSelector = 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) {
-    var V; // eslint-disable-next-line no-constant-condition
-
+    var V;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       var exprValue = GetValue(Evaluate(node.test));
-
       if (!exprValue) {
         return NormalCompletion(V);
       }
-
       var stmtResult = Evaluate(node.body);
-
       if (!LoopContinues(stmtResult)) {
         return UpdateEmpty(stmtResult, V);
       }
-
       if (stmtResult.Value !== 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) {
-    var V; // eslint-disable-next-line no-constant-condition
-
+    var V;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       var stmtResult = Evaluate(node.body);
-
       if (!LoopContinues(stmtResult)) {
         return UpdateEmpty(stmtResult, V);
       }
-
       if (stmtResult.Value !== Empty) {
         V = stmtResult.Value;
       }
-
       var exprValue = GetValue(Evaluate(node.test));
-
       if (!exprValue) {
         return 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) {
     var lhs = node.left;
     var isVariableDeclaration = lhs.type === "VariableDeclaration";
@@ -700,77 +572,62 @@ export function cook(rootAst, codeSource) {
     var uninitializedBoundNames = lhsKind === "lexicalBinding" ? collectBoundNames(lhs) : [];
     var iterationKind = node.type === "ForInStatement" ? "enumerate" : "iterate";
     var 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) {
     var runningContext = getRunningContext();
     var oldEnv = runningContext.LexicalEnvironment;
-
     if (uninitializedBoundNames.length > 0) {
       var newEnv = new DeclarativeEnvironment(oldEnv);
-
       for (var name of uninitializedBoundNames) {
         newEnv.CreateMutableBinding(name, false);
       }
-
       runningContext.LexicalEnvironment = newEnv;
     }
-
     var exprRef = Evaluate(expr);
     runningContext.LexicalEnvironment = oldEnv;
     var exprValue = GetValue(exprRef);
-
     if (iterationKind === "enumerate") {
       if (exprValue === null || exprValue === undefined) {
         return new CompletionRecord("break", Empty);
       }
-
       var _iterator = EnumerateObjectProperties(exprValue);
-
       return NormalCompletion(_iterator);
     }
-
     var iterator = CreateListIteratorRecord(exprValue);
     return NormalCompletion(iterator);
   }
-
   function ForInOfBodyEvaluation(node, stmt, iteratorRecord, iterationKind, lhsKind) {
     var lhs = lhsKind === "assignment" ? node : node.declarations[0].id;
     var oldEnv = getRunningContext().LexicalEnvironment;
-    var V; // When `destructuring` is false,
+    var V;
+    // When `destructuring` is false,
     // For `node` whose `kind` is assignment:
     //   `lhs` is an `Identifier` or a `MemberExpression`,
     // Otherwise:
     //   `lhs` is an `Identifier`.
-
-    var destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern"; // eslint-disable-next-line no-constant-condition
-
+    var destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern";
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       var {
         done,
         value: nextValue
       } = iteratorRecord.next();
-
       if (done) {
         return NormalCompletion(V);
       }
-
       var lhsRef = void 0;
       var iterationEnv = void 0;
-
       if (lhsKind === "lexicalBinding") {
         iterationEnv = new DeclarativeEnvironment(oldEnv);
         ForDeclarationBindingInstantiation(node, iterationEnv);
         getRunningContext().LexicalEnvironment = iterationEnv;
-
         if (!destructuring) {
           var [lhsName] = collectBoundNames(lhs);
           lhsRef = ResolveBinding(lhsName);
@@ -778,58 +635,49 @@ export 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" ? InitializeReferencedBinding(lhsRef, nextValue) : PutValue(lhsRef, nextValue);
       var result = Evaluate(stmt);
       getRunningContext().LexicalEnvironment = oldEnv;
-
       if (!LoopContinues(result)) {
         var status = UpdateEmpty(result, V);
-
         if (!(iterationKind === "enumerate" || iteratorRecord.return === undefined)) {
           // Perform *IteratorClose*
           // https://tc39.es/ecma262/#sec-iteratorclose
           var innerResult = iteratorRecord.return();
-
           if (!innerResult || !["object", "function"].includes(typeof innerResult)) {
             throw new TypeError("Iterator result is not an object");
           }
         }
-
         return status;
       }
-
       if (result.Value !== Empty) {
         V = result.Value;
       }
     }
-  } // https://tc39.es/ecma262/#sec-enumerate-object-properties
-
+  }
 
+  // https://tc39.es/ecma262/#sec-enumerate-object-properties
   function* EnumerateObjectProperties(value) {
     for (var _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 … ; … ; … ) …`
       var oldEnv = getRunningContext().LexicalEnvironment;
       var loopEnv = new DeclarativeEnvironment(oldEnv);
       var isConst = node.init.kind === "const";
       var boundNames = collectBoundNames(node.init);
-
       for (var dn of boundNames) {
         if (isConst) {
           loopEnv.CreateImmutableBinding(dn, true);
@@ -837,113 +685,94 @@ export function cook(rootAst, codeSource) {
           loopEnv.CreateMutableBinding(dn, false);
         }
       }
-
       getRunningContext().LexicalEnvironment = loopEnv;
       Evaluate(node.init);
       var perIterationLets = isConst ? [] : Array.from(boundNames);
       var bodyResult = ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
       getRunningContext().LexicalEnvironment = oldEnv;
       return bodyResult;
-    } // `for ( … ; … ; … ) …`
-
-
+    }
+    // `for ( … ; … ; … ) …`
     if (node.init) {
       var exprRef = Evaluate(node.init);
       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);
-    var V; // eslint-disable-next-line no-constant-condition
-
+    var V;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       if (test) {
         var testRef = Evaluate(test);
         var testValue = GetValue(testRef);
-
         if (!testValue) {
           return NormalCompletion(V);
         }
       }
-
       var result = Evaluate(stmt);
-
       if (!LoopContinues(result)) {
         return UpdateEmpty(result, V);
       }
-
       if (result.Value) {
         V = result.Value;
       }
-
       CreatePerIterationEnvironment(perIterationBindings);
-
       if (increment) {
         var incRef = Evaluate(increment);
         GetValue(incRef);
       }
     }
-  } // https://tc39.es/ecma262/#sec-createperiterationenvironment
-
+  }
 
+  // https://tc39.es/ecma262/#sec-createperiterationenvironment
   function CreatePerIterationEnvironment(perIterationBindings) {
     if (perIterationBindings.length === 0) {
       return;
     }
-
     var lastIterationEnv = getRunningContext().LexicalEnvironment;
     var outer = lastIterationEnv.OuterEnv;
     var thisIterationEnv = new DeclarativeEnvironment(outer);
-
     for (var bn of perIterationBindings) {
       thisIterationEnv.CreateMutableBinding(bn, false);
       var 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") {
       RequireObjectCoercible(value);
-
       if (pattern.properties.length > 0) {
         PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
       }
-
       return NormalCompletion(Empty);
     }
-
     var iteratorRecord = 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) {
     var excludedNames = new Set();
-
     for (var prop of properties) {
       if (prop.type === "Property") {
         var propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : EvaluateComputedPropertyName(prop.key);
         var valueTarget = prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value;
-
         if (valueTarget.type === "Identifier") {
           var lref = ResolveBinding(valueTarget.name);
           var v = GetV(value, propName);
-
           if (prop.value.type === "AssignmentPattern" && v === undefined) {
             // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
             var defaultValue = Evaluate(prop.value.right);
             v = GetValue(defaultValue);
           }
-
           PutValue(lref, v);
           excludedNames.add(propName);
         } else {
@@ -954,21 +783,18 @@ export 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) {
     var assignmentTarget = node.type === "AssignmentPattern" ? node.left : node;
     var isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
     var lref;
-
     if (!isObjectOrArray) {
       lref = Evaluate(assignmentTarget).Value;
     }
-
     var v = GetV(value, propertyName);
     var rhsValue;
-
     if (node.type === "AssignmentPattern" && v === undefined) {
       // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
       var defaultValue = Evaluate(node.right);
@@ -976,50 +802,41 @@ export function cook(rootAst, codeSource) {
     } else {
       rhsValue = v;
     }
-
     if (isObjectOrArray) {
       return DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
     }
-
     return PutValue(lref, rhsValue);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
   function RestDestructuringAssignmentEvaluation(restProperty, value, excludedNames) {
     var lref = Evaluate(restProperty.argument).Value;
     var restObj = CopyDataProperties({}, value, excludedNames);
     return PutValue(lref, restObj);
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
   function IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
     var status = NormalCompletion(Empty);
-
     for (var element of elements) {
       if (!element) {
         iteratorRecord.next();
         status = NormalCompletion(Empty);
         continue;
       }
-
       var assignmentTarget = element.type === "RestElement" ? element.argument : element.type === "AssignmentPattern" ? element.left : element;
       var isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
       var lref = void 0;
-
       if (!isObjectOrArray) {
         lref = Evaluate(assignmentTarget).Value;
       }
-
       var v = void 0;
-
       if (element.type !== "RestElement") {
         var {
           done,
           value: nextValue
         } = iteratorRecord.next();
-
         var _value2 = done ? undefined : nextValue;
-
         if (element.type === "AssignmentPattern" && _value2 === undefined) {
           // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
           var defaultValue = Evaluate(element.right);
@@ -1030,59 +847,53 @@ export function cook(rootAst, codeSource) {
       } else {
         // RestElement
         v = [];
-        var n = 0; // eslint-disable-next-line no-constant-condition
-
+        var n = 0;
+        // eslint-disable-next-line no-constant-condition
         while (true) {
           var {
             done: _done,
             value: _nextValue
           } = iteratorRecord.next();
-
           if (_done) {
             break;
           }
-
           v[n] = _nextValue;
           n++;
         }
       }
-
       if (isObjectOrArray) {
         status = DestructuringAssignmentEvaluation(assignmentTarget, v);
       } else {
         status = 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) {
     var propertyNameReference = Evaluate(expression);
     var propertyNameValue = GetValue(propertyNameReference);
     var propertyKey = ToPropertyKey(propertyNameValue);
     return new 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) {
     var propertyNameString = identifier.name;
     return new ReferenceRecord(baseValue, propertyNameString, strict);
-  } // Block statements.
-  // https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
-
+  }
 
+  // Block statements.
+  // https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
   function BlockDeclarationInstantiation(code, env) {
     var declarations = collectScopedDeclarations(code, {
       var: false,
       topLevel: false
     });
-
     for (var d of declarations) {
       var IsConstantDeclaration = d.type === "VariableDeclaration" && d.kind === "const";
-
       for (var dn of collectBoundNames(d)) {
         if (IsConstantDeclaration) {
           env.CreateImmutableBinding(dn, true);
@@ -1090,64 +901,52 @@ export function cook(rootAst, codeSource) {
           env.CreateMutableBinding(dn, false);
         }
       }
-
       if (d.type === "FunctionDeclaration") {
         var [_fn] = collectBoundNames(d);
-
         var _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) {
     var thisValue;
-
     if (ref instanceof ReferenceRecord) {
       if (IsPropertyReference(ref)) {
         thisValue = ref.Base;
       }
     }
-
     var argList = ArgumentListEvaluation(args);
-
     if (typeof func !== "function") {
       var funcName = codeSource.substring(callee.start, callee.end);
       throw new TypeError("".concat(funcName, " is not a function"));
     }
-
     var result = func.apply(thisValue, argList);
     sanitize(result);
     return NormalCompletion(result);
-  } // https://tc39.es/ecma262/#sec-evaluatenew
-
+  }
 
+  // https://tc39.es/ecma262/#sec-evaluatenew
   function EvaluateNew(constructExpr, args) {
     var ref = Evaluate(constructExpr);
     var constructor = GetValue(ref);
     var argList = ArgumentListEvaluation(args);
-
     if (typeof constructor !== "function" || constructor[IsConstructor] === false) {
       var constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError("".concat(constructorName, " is not a constructor"));
     }
-
     if (!isAllowedConstructor(constructor)) {
       var _constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
-
       throw new TypeError("".concat(_constructorName, " is not an allowed constructor"));
     }
-
     return NormalCompletion(new constructor(...argList));
-  } // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
   function ArgumentListEvaluation(args) {
     var array = [];
-
     if (Array.isArray(args)) {
       for (var arg of args) {
         if (arg.type === "SpreadElement") {
@@ -1159,32 +958,27 @@ export function cook(rootAst, codeSource) {
       }
     } else {
       array.push(GetTemplateObject(args));
-
       for (var expr of args.expressions) {
         array.push(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[SourceNode]);
     PrepareForOrdinaryCall(closure);
     var 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) {
     var calleeContext = new ExecutionContext();
     calleeContext.Function = F;
@@ -1193,42 +987,36 @@ export 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[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 CompletionRecord("return", GetValue(Evaluate(body)));
-  } // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
   function EvaluateStatementList(statements) {
     var result = NormalCompletion(Empty);
-
     for (var stmt of statements) {
       var s = Evaluate(stmt);
-
       if (s.Type !== "normal") {
         return s;
       }
-
       result = UpdateEmpty(result, s.Value);
     }
-
     return result;
-  } // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
-
+  }
 
+  // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
   function FunctionDeclarationInstantiation(func, args) {
     var calleeContext = getRunningContext();
     var code = func[ECMAScriptCode];
@@ -1239,19 +1027,17 @@ export function cook(rootAst, codeSource) {
       var: true,
       topLevel: true
     });
-    var varNames = collectBoundNames(varDeclarations); // `functionNames` ∈ `varNames`
-    // `functionsToInitialize` ≈ `functionNames`
+    var varNames = collectBoundNames(varDeclarations);
 
+    // `functionNames` ∈ `varNames`
+    // `functionsToInitialize` ≈ `functionNames`
     var functionNames = [];
     var functionsToInitialize = [];
-
     for (var i = varDeclarations.length - 1; i >= 0; i--) {
       var d = varDeclarations[i];
-
       if (d.type === "FunctionDeclaration") {
         ThrowIfFunctionIsInvalid(d);
         var [_fn2] = collectBoundNames(d);
-
         if (!functionNames.includes(_fn2)) {
           functionNames.unshift(_fn2);
           functionsToInitialize.unshift(d);
@@ -1260,18 +1046,14 @@ export function cook(rootAst, codeSource) {
         throw new SyntaxError("Var declaration is not recommended, use `let` or `const` instead");
       }
     }
-
     var env = calleeContext.LexicalEnvironment;
-
     for (var paramName of parameterNames) {
       // In strict mode, it's guaranteed no duplicate params exist.
       env.CreateMutableBinding(paramName, false);
     }
-
     var iteratorRecord = CreateListIteratorRecord(args);
     IteratorBindingInitialization(formals, iteratorRecord, env);
     var varEnv;
-
     if (!hasParameterExpressions) {
       // NOTE: Only a single Environment Record is needed for the parameters
       // and top-level vars.
@@ -1282,24 +1064,22 @@ export 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 DeclarativeEnvironment(env);
-      calleeContext.VariableEnvironment = varEnv; // `varNames` are unique.
-
+      calleeContext.VariableEnvironment = varEnv;
+      // `varNames` are unique.
       for (var _n of varNames) {
         varEnv.CreateMutableBinding(_n, false);
         var initialValue = void 0;
-
         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.
       }
     }
@@ -1310,7 +1090,6 @@ export function cook(rootAst, codeSource) {
       var: false,
       topLevel: true
     });
-
     for (var _d of lexDeclarations) {
       for (var dn of collectBoundNames(_d)) {
         // Only lexical VariableDeclaration here in top-level.
@@ -1321,25 +1100,21 @@ export function cook(rootAst, codeSource) {
         }
       }
     }
-
     for (var f of functionsToInitialize) {
       var [_fn3] = collectBoundNames(f);
-
       var _fo2 = InstantiateFunctionObject(f, lexEnv);
-
       varEnv.SetMutableBinding(_fn3, _fo2, 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) {
     var scope = getRunningContext().LexicalEnvironment;
-
     if (functionExpression.id) {
       var name = functionExpression.id.name;
       var funcEnv = new DeclarativeEnvironment(scope);
@@ -1349,25 +1124,23 @@ export function cook(rootAst, codeSource) {
       return closure;
     } else {
       var _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) {
     var scope = getRunningContext().LexicalEnvironment;
     var closure = OrdinaryFunctionCreate(arrowFunction, scope, false);
     return closure;
-  } // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
-
+  }
 
+  // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
   function OrdinaryFunctionCreate(sourceNode, scope, isConstructor) {
     var F = function () {
       // eslint-disable-next-line prefer-rest-params
       return CallFunction(F, arguments);
     };
-
     Object.defineProperties(F, {
       [SourceNode]: {
         value: sourceNode
@@ -1386,36 +1159,32 @@ export 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":
         RequireObjectCoercible(value);
         return PropertyBindingInitialization(node.properties, value, environment);
-
       case "ArrayPattern":
         {
           var iteratorRecord = 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) {
     var excludedNames = new Set();
-
     for (var 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);
@@ -1425,36 +1194,31 @@ export function cook(rootAst, codeSource) {
         excludedNames.add(P);
       }
     }
-
     return NormalCompletion(Empty);
-  } // https://tc39.es/ecma262/#prod-ComputedPropertyName
-
+  }
 
+  // https://tc39.es/ecma262/#prod-ComputedPropertyName
   function EvaluateComputedPropertyName(node) {
     var propName = GetValue(Evaluate(node));
     return 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) {
     var lhs = ResolveBinding(restProperty.argument.name, environment);
     var restObj = CopyDataProperties({}, value, excludedNames);
-
     if (!environment) {
       return PutValue(lhs, restObj);
     }
-
     return 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 NormalCompletion(Empty);
     }
-
     var result;
-
     for (var _node of elements) {
       if (!_node) {
         // Elision element.
@@ -1465,37 +1229,33 @@ export function cook(rootAst, codeSource) {
         if (_node.argument.type === "Identifier") {
           var lhs = ResolveBinding(_node.argument.name, environment);
           var A = [];
-          var n = 0; // eslint-disable-next-line no-constant-condition
-
+          var n = 0;
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             var {
               done,
               value: _value3
             } = iteratorRecord.next();
-
             if (done) {
               result = environment ? InitializeReferencedBinding(lhs, A) : PutValue(lhs, A);
               break;
             }
-
             A[n] = _value3;
             n++;
           }
         } else {
           var _A = [];
-          var _n2 = 0; // eslint-disable-next-line no-constant-condition
-
+          var _n2 = 0;
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             var {
               done: _done2,
               value: _value4
             } = iteratorRecord.next();
-
             if (_done2) {
               result = BindingInitialization(_node.argument, _A, environment);
               break;
             }
-
             _A[_n2] = _value4;
             _n2++;
           }
@@ -1503,7 +1263,6 @@ export function cook(rootAst, codeSource) {
       } else {
         // Normal element.
         var bindingElement = _node.type === "AssignmentPattern" ? _node.left : _node;
-
         switch (bindingElement.type) {
           case "ObjectPattern":
           case "ArrayPattern":
@@ -1513,113 +1272,88 @@ export function cook(rootAst, codeSource) {
                 done: _done3,
                 value: _value5
               } = iteratorRecord.next();
-
               if (!_done3) {
                 v = _value5;
               }
-
               if (_node.type === "AssignmentPattern" && v === undefined) {
                 var defaultValue = Evaluate(_node.right);
                 v = GetValue(defaultValue);
               }
-
               result = BindingInitialization(bindingElement, v, environment);
               break;
             }
-
           case "Identifier":
             {
               var bindingId = bindingElement.name;
-
               var _lhs3 = ResolveBinding(bindingId, environment);
-
               var _v = void 0;
-
               var {
                 done: _done4,
                 value: _value6
               } = iteratorRecord.next();
-
               if (!_done4) {
                 _v = _value6;
               }
-
               if (_node.type === "AssignmentPattern" && _v === undefined) {
                 // IsAnonymousFunctionDefinition(Initializer)
                 var _defaultValue = Evaluate(_node.right);
-
                 _v = GetValue(_defaultValue);
               }
-
               result = environment ? InitializeReferencedBinding(_lhs3, _v) : PutValue(_lhs3, _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) {
     var isIdentifier = node.type === "Identifier" || node.type === "AssignmentPattern" && node.left.type === "Identifier";
-
     if (isIdentifier) {
       var bindingId = node.type === "Identifier" ? node.name : node.left.name;
       var lhs = ResolveBinding(bindingId, environment);
-
       var _v2 = GetV(value, propertyName);
-
       if (node.type === "AssignmentPattern" && _v2 === undefined) {
         // If IsAnonymousFunctionDefinition(Initializer)
         var defaultValue = Evaluate(node.right);
         _v2 = GetValue(defaultValue);
       }
-
       if (!environment) {
         return PutValue(lhs, _v2);
       }
-
       return InitializeReferencedBinding(lhs, _v2);
     }
-
     var v = GetV(value, propertyName);
-
     if (node.type === "AssignmentPattern" && v === undefined) {
       var _defaultValue2 = Evaluate(node.right);
-
       v = GetValue(_defaultValue2);
     }
-
     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 NormalCompletion(Empty);
   }
-
   function ThrowIfFunctionIsInvalid(func) {
     if (func.async || func.generator) {
       throw new SyntaxError("".concat(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 GetValue(Evaluate(rootAst));
   }
-
   (_hooks$beforeEvaluate3 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate3 === void 0 ? void 0 : _hooks$beforeEvaluate3.call(hooks, rootAst);
   ThrowIfFunctionIsInvalid(rootAst);
-  var [fn] = collectBoundNames(rootAst); // Create an immutable binding for the root function.
-
+  var [fn] = collectBoundNames(rootAst);
+  // Create an immutable binding for the root function.
   rootEnv.CreateImmutableBinding(fn, true);
   var fo = InstantiateFunctionObject(rootAst, rootEnv);
   rootEnv.InitializeBinding(fn, fo);