@next-core/cook 2.2.16 → 2.2.18

package/dist/esm/cook.js

@@ -5,31 +5,31 @@ import { collectBoundNames, collectScopedDeclarations, containsExpression } from
 /** For next-core internal usage only. */
 export function cook(rootAst, codeSource) {
   var _hooks$beforeEvaluate3;
-  var {
+  let {
     rules,
     globalVariables = {},
     hooks = {}
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var expressionOnly = rootAst.type !== "FunctionDeclaration";
-  var rootEnv = new DeclarativeEnvironment(null);
-  var rootContext = new ExecutionContext();
+  const expressionOnly = rootAst.type !== "FunctionDeclaration";
+  const rootEnv = new DeclarativeEnvironment(null);
+  const rootContext = new ExecutionContext();
   rootContext.VariableEnvironment = rootEnv;
   rootContext.LexicalEnvironment = rootEnv;
-  var executionContextStack = [rootContext];
-  for (var [key, value] of Object.entries(globalVariables)) {
+  const executionContextStack = [rootContext];
+  for (const [key, value] of Object.entries(globalVariables)) {
     rootEnv.CreateImmutableBinding(key, true);
     rootEnv.InitializeBinding(key, value);
   }
-  var TemplateMap = new WeakMap();
+  const TemplateMap = new WeakMap();
 
   // https://tc39.es/ecma262/#sec-gettemplateobject
   function GetTemplateObject(templateLiteral) {
-    var memo = TemplateMap.get(templateLiteral);
+    const 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);
+    const rawObj = templateLiteral.quasis.map(quasi => quasi.value.raw);
+    const template = templateLiteral.quasis.map(quasi => quasi.value.cooked);
     Object.freeze(rawObj);
     Object.defineProperty(template, "raw", {
       value: rawObj,
@@ -49,12 +49,12 @@ export function cook(rootAst, codeSource) {
       case "ArrayExpression":
         {
           // https://tc39.es/ecma262/#sec-array-initializer
-          var array = [];
-          for (var element of node.elements) {
+          const array = [];
+          for (const element of node.elements) {
             if (!element) {
               array.length += 1;
             } else if (element.type === "SpreadElement") {
-              var spreadValues = GetValue(Evaluate(element.argument));
+              const spreadValues = GetValue(Evaluate(element.argument));
               array.push(...spreadValues);
             } else {
               array.push(GetValue(Evaluate(element)));
@@ -66,24 +66,24 @@ export function cook(rootAst, codeSource) {
         {
           // https://tc39.es/ecma262/#sec-arrow-function-definitions
           ThrowIfFunctionIsInvalid(node);
-          var closure = InstantiateArrowFunctionExpression(node);
+          const 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);
+          const leftRef = Evaluate(node.left);
+          const leftValue = GetValue(leftRef);
+          const rightRef = Evaluate(node.right).Value;
+          const rightValue = GetValue(rightRef);
           if (expressionOnly && node.operator === "|>") {
             // Minimal pipeline operator is supported only in expression-only mode.
             // See https://tc39.es/proposal-pipeline-operator
             // and https://github.com/tc39/proposal-pipeline-operator
             if (typeof rightValue !== "function") {
-              var funcName = codeSource.substring(node.right.start, node.right.end);
-              throw new TypeError("".concat(funcName, " is not a function"));
+              const funcName = codeSource.substring(node.right.start, node.right.end);
+              throw new TypeError(`${funcName} is not a function`);
             }
-            var thisValue;
+            let thisValue;
             if (rightRef instanceof ReferenceRecord) {
               if (IsPropertyReference(rightRef)) {
                 thisValue = rightRef.Base;
@@ -92,14 +92,14 @@ export function cook(rootAst, codeSource) {
             return NormalCompletion(rightValue.call(thisValue, leftValue));
           }
           // https://tc39.es/ecma262/#sec-additive-operators
-          var result = ApplyStringOrNumericBinaryOperator(leftValue, node.operator, rightValue);
+          const 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);
+          const ref = Evaluate(node.callee, optionalChainRef).Value;
+          const func = GetValue(ref);
           if ((func === undefined || func === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return NormalCompletion(undefined);
@@ -122,11 +122,11 @@ export function cook(rootAst, codeSource) {
           if (node.regex) {
             if (node.value === null) {
               // Invalid regular expression fails silently in @babel/parser.
-              throw new SyntaxError("Invalid regular expression: ".concat(node.raw));
+              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: ".concat(node.raw));
+              throw new SyntaxError(`Unsupported unicode flag in regular expression: ${node.raw}`);
             }
           }
           return NormalCompletion(node.value);
@@ -134,34 +134,35 @@ export function cook(rootAst, codeSource) {
       case "LogicalExpression":
         {
           // https://tc39.es/ecma262/#sec-binary-logical-operators
-          var _leftValue = GetValue(Evaluate(node.left));
+          const leftValue = GetValue(Evaluate(node.left));
           switch (node.operator) {
             case "&&":
-              return NormalCompletion(_leftValue && GetValue(Evaluate(node.right)));
+              return NormalCompletion(leftValue && GetValue(Evaluate(node.right)));
             case "||":
-              return NormalCompletion(_leftValue || GetValue(Evaluate(node.right)));
+              return NormalCompletion(leftValue || GetValue(Evaluate(node.right)));
             case "??":
-              return NormalCompletion(_leftValue !== null && _leftValue !== void 0 ? _leftValue : GetValue(Evaluate(node.right)));
+              return NormalCompletion(leftValue ?? 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 '".concat(node.operator, "'"));
+              `Unsupported logical operator '${node.operator}'`);
           }
         }
       case "MemberExpression":
         {
           // https://tc39.es/ecma262/#sec-property-accessors
-          var baseReference = Evaluate(node.object, optionalChainRef).Value;
-          var baseValue = GetValue(baseReference);
+          const baseReference = Evaluate(node.object, optionalChainRef).Value;
+          const 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);
+          const 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
@@ -169,16 +170,16 @@ export function cook(rootAst, codeSource) {
       case "ObjectExpression":
         {
           // https://tc39.es/ecma262/#sec-object-initializer
-          var object = {};
-          for (var prop of node.properties) {
+          const object = {};
+          for (const prop of node.properties) {
             if (prop.type === "SpreadElement") {
-              var fromValue = GetValue(Evaluate(prop.argument));
+              const fromValue = GetValue(Evaluate(prop.argument));
               CopyDataProperties(object, fromValue, new Set());
             } else {
               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);
+              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");
               }
@@ -190,19 +191,19 @@ export function cook(rootAst, codeSource) {
       case "SequenceExpression":
         {
           // https://tc39.es/ecma262/#sec-comma-operator
-          var _result2;
-          for (var expr of node.expressions) {
-            _result2 = NormalCompletion(GetValue(Evaluate(expr)));
+          let result;
+          for (const expr of node.expressions) {
+            result = NormalCompletion(GetValue(Evaluate(expr)));
           }
-          return _result2;
+          return result;
         }
       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));
+          const chunks = [node.quasis[0].value.cooked];
+          let index = 0;
+          for (const expr of node.expressions) {
+            const val = GetValue(Evaluate(expr));
             chunks.push(String(val));
             chunks.push(node.quasis[index += 1].value.cooked);
           }
@@ -211,34 +212,34 @@ export function cook(rootAst, codeSource) {
       case "TaggedTemplateExpression":
         {
           // https://tc39.es/ecma262/#sec-tagged-templates
-          var tagRef = Evaluate(node.tag).Value;
-          var tagFunc = GetValue(tagRef);
+          const tagRef = Evaluate(node.tag).Value;
+          const tagFunc = GetValue(tagRef);
           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;
+          const ref = Evaluate(node.argument).Value;
           if (!expressionOnly && node.operator === "delete") {
             // Delete operator is supported only in function mode.
-            if (!(_ref instanceof ReferenceRecord)) {
+            if (!(ref instanceof ReferenceRecord)) {
               return NormalCompletion(true);
             }
             // istanbul ignore else
-            if (IsPropertyReference(_ref)) {
-              var deleteStatus = delete _ref.Base[_ref.ReferenceName];
+            if (IsPropertyReference(ref)) {
+              const deleteStatus = delete ref.Base[ref.ReferenceName];
               return NormalCompletion(deleteStatus);
             }
             // Should never reach here in strict mode.
           }
           if (node.operator === "typeof") {
-            if (_ref instanceof ReferenceRecord && _ref.Base === "unresolvable") {
+            if (ref instanceof ReferenceRecord && ref.Base === "unresolvable") {
               return NormalCompletion("undefined");
             }
-            return NormalCompletion(typeof GetValue(_ref));
+            return NormalCompletion(typeof GetValue(ref));
           }
-          return NormalCompletion(ApplyUnaryOperator(GetValue(_ref), node.operator));
+          return NormalCompletion(ApplyUnaryOperator(GetValue(ref), node.operator));
         }
     }
     if (!expressionOnly) {
@@ -249,24 +250,24 @@ 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;
+                const lref = Evaluate(node.left).Value;
                 // Todo: IsAnonymousFunctionDefinition(lref)
-                var _rref = Evaluate(node.right);
-                var _rval = GetValue(_rref);
-                PutValue(_lref, _rval);
-                return NormalCompletion(_rval);
+                const rref = Evaluate(node.right);
+                const rval = GetValue(rref);
+                PutValue(lref, rval);
+                return NormalCompletion(rval);
               }
-              var _rref2 = Evaluate(node.right);
-              var _rval2 = GetValue(_rref2);
-              DestructuringAssignmentEvaluation(node.left, _rval2);
-              return NormalCompletion(_rval2);
+              const rref = Evaluate(node.right);
+              const rval = GetValue(rref);
+              DestructuringAssignmentEvaluation(node.left, rval);
+              return NormalCompletion(rval);
             }
             // Operators other than `=`.
-            var lref = Evaluate(node.left).Value;
-            var lval = GetValue(lref);
-            var rref = Evaluate(node.right);
-            var rval = GetValue(rref);
-            var r = ApplyStringOrNumericAssignment(lval, node.operator, rval);
+            const lref = Evaluate(node.left).Value;
+            const lval = GetValue(lref);
+            const rref = Evaluate(node.right);
+            const rval = GetValue(rref);
+            const r = ApplyStringOrNumericAssignment(lval, node.operator, rval);
             PutValue(lref, r);
             return NormalCompletion(r);
           }
@@ -276,11 +277,11 @@ export function cook(rootAst, codeSource) {
             if (!node.body.length) {
               return NormalCompletion(Empty);
             }
-            var oldEnv = getRunningContext().LexicalEnvironment;
-            var blockEnv = new DeclarativeEnvironment(oldEnv);
+            const oldEnv = getRunningContext().LexicalEnvironment;
+            const blockEnv = new DeclarativeEnvironment(oldEnv);
             BlockDeclarationInstantiation(node.body, blockEnv);
             getRunningContext().LexicalEnvironment = blockEnv;
-            var blockValue = EvaluateStatementList(node.body);
+            const blockValue = EvaluateStatementList(node.body);
             getRunningContext().LexicalEnvironment = oldEnv;
             return blockValue;
           }
@@ -320,9 +321,9 @@ export function cook(rootAst, codeSource) {
         case "ReturnStatement":
           {
             // https://tc39.es/ecma262/#sec-return-statement
-            var v;
+            let v;
             if (node.argument) {
-              var exprRef = Evaluate(node.argument);
+              const exprRef = Evaluate(node.argument);
               v = GetValue(exprRef);
             }
             return new CompletionRecord("return", v);
@@ -333,9 +334,9 @@ export function cook(rootAst, codeSource) {
         case "UpdateExpression":
           {
             // https://tc39.es/ecma262/#sec-update-expressions
-            var lhs = Evaluate(node.argument).Value;
-            var oldValue = Number(GetValue(lhs));
-            var newValue = node.operator === "++" ? oldValue + 1 : oldValue - 1;
+            const lhs = Evaluate(node.argument).Value;
+            const oldValue = Number(GetValue(lhs));
+            const newValue = node.operator === "++" ? oldValue + 1 : oldValue - 1;
             PutValue(lhs, newValue);
             return NormalCompletion(node.prefix ? newValue : oldValue);
           }
@@ -344,67 +345,67 @@ export function cook(rootAst, codeSource) {
         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;
+            const exprRef = Evaluate(node.discriminant);
+            const switchValue = GetValue(exprRef);
+            const oldEnv = getRunningContext().LexicalEnvironment;
+            const blockEnv = new DeclarativeEnvironment(oldEnv);
+            BlockDeclarationInstantiation(node.cases, blockEnv);
+            getRunningContext().LexicalEnvironment = blockEnv;
+            const R = CaseBlockEvaluation(node.cases, switchValue);
+            getRunningContext().LexicalEnvironment = oldEnv;
             return EvaluateBreakableStatement(R);
           }
         case "TryStatement":
           {
             // https://tc39.es/ecma262/#sec-try-statement
-            var _R;
+            let R;
             try {
-              _R = Evaluate(node.block);
+              R = Evaluate(node.block);
             } catch (error) {
               if (node.handler) {
                 var _hooks$beforeEvaluate2;
                 (_hooks$beforeEvaluate2 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate2 === void 0 || _hooks$beforeEvaluate2.call(hooks, node.handler);
-                _R = CatchClauseEvaluation(node.handler, error);
+                R = CatchClauseEvaluation(node.handler, error);
               } else {
                 throw error;
               }
             } finally {
               if (node.finalizer) {
-                var F = Evaluate(node.finalizer);
+                const F = Evaluate(node.finalizer);
                 if (F.Type !== "normal") {
-                  _R = F;
+                  R = F;
                 }
               }
             }
-            return _R;
+            return R;
           }
         case "VariableDeclaration":
           {
             // https://tc39.es/ecma262/#sec-declarations-and-the-variable-statement
-            var _result3;
-            for (var declarator of node.declarations) {
+            let result;
+            for (const declarator of node.declarations) {
               if (!declarator.init) {
                 // Assert: a declarator without init is always an identifier.
                 if (node.kind === "var") {
-                  _result3 = NormalCompletion(Empty);
+                  result = NormalCompletion(Empty);
                 } else {
-                  var _lhs = ResolveBinding(declarator.id.name);
-                  _result3 = InitializeReferencedBinding(_lhs, undefined);
+                  const lhs = ResolveBinding(declarator.id.name);
+                  result = InitializeReferencedBinding(lhs, undefined);
                 }
               } else if (declarator.id.type === "Identifier") {
-                var bindingId = declarator.id.name;
-                var _lhs2 = ResolveBinding(bindingId);
+                const bindingId = declarator.id.name;
+                const lhs = ResolveBinding(bindingId);
                 // Todo: IsAnonymousFunctionDefinition(Initializer)
-                var rhs = Evaluate(declarator.init);
-                var _value = GetValue(rhs);
-                _result3 = node.kind === "var" ? PutValue(_lhs2, _value) : InitializeReferencedBinding(_lhs2, _value);
+                const rhs = Evaluate(declarator.init);
+                const value = GetValue(rhs);
+                result = node.kind === "var" ? PutValue(lhs, value) : InitializeReferencedBinding(lhs, value);
               } else {
-                var _rhs = Evaluate(declarator.init);
-                var _rval3 = GetValue(_rhs);
-                _result3 = BindingInitialization(declarator.id, _rval3, node.kind === "var" ? undefined : getRunningContext().LexicalEnvironment);
+                const rhs = Evaluate(declarator.init);
+                const rval = GetValue(rhs);
+                result = BindingInitialization(declarator.id, rval, node.kind === "var" ? undefined : getRunningContext().LexicalEnvironment);
               }
             }
-            return _result3;
+            return result;
           }
         case "WhileStatement":
           // https://tc39.es/ecma262/#sec-while-statement
@@ -412,7 +413,7 @@ export function cook(rootAst, codeSource) {
       }
     }
     // eslint-disable-next-line no-console
-    throw new SyntaxError("Unsupported node type `".concat(node.type, "`"));
+    throw new SyntaxError(`Unsupported node type \`${node.type}\``);
   }
 
   // https://tc39.es/ecma262/#sec-execution-contexts
@@ -434,14 +435,14 @@ export function cook(rootAst, codeSource) {
     if (!node.param) {
       return Evaluate(node.body);
     }
-    var oldEnv = getRunningContext().LexicalEnvironment;
-    var catchEnv = new DeclarativeEnvironment(oldEnv);
-    for (var argName of collectBoundNames(node.param)) {
+    const oldEnv = getRunningContext().LexicalEnvironment;
+    const catchEnv = new DeclarativeEnvironment(oldEnv);
+    for (const argName of collectBoundNames(node.param)) {
       catchEnv.CreateMutableBinding(argName, false);
     }
     getRunningContext().LexicalEnvironment = catchEnv;
     BindingInitialization(node.param, thrownValue, catchEnv);
-    var B = Evaluate(node.body);
+    const B = Evaluate(node.body);
     getRunningContext().LexicalEnvironment = oldEnv;
     return B;
   }
@@ -455,42 +456,42 @@ export function cook(rootAst, codeSource) {
   // 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) {
+    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) {
-        var _R2 = Evaluate(C);
-        if (_R2.Value !== Empty) {
-          V = _R2.Value;
+        const R = Evaluate(C);
+        if (R.Value !== Empty) {
+          V = R.Value;
         }
-        if (_R2.Type !== "normal") {
-          return UpdateEmpty(_R2, V);
+        if (R.Type !== "normal") {
+          return UpdateEmpty(R, V);
         }
       }
     }
     if (!hasDefaultCase) {
       return NormalCompletion(V);
     }
-    var foundInB = false;
-    var B = cases.slice(defaultCaseIndex + 1);
+    let foundInB = false;
+    const B = cases.slice(defaultCaseIndex + 1);
     if (!found) {
-      for (var _C of B) {
+      for (const C of B) {
         if (!foundInB) {
-          foundInB = CaseClauseIsSelected(_C, input);
+          foundInB = CaseClauseIsSelected(C, input);
         }
         if (foundInB) {
-          var _R3 = Evaluate(_C);
-          if (_R3.Value !== Empty) {
-            V = _R3.Value;
+          const R = Evaluate(C);
+          if (R.Value !== Empty) {
+            V = R.Value;
           }
-          if (_R3.Type !== "normal") {
-            return UpdateEmpty(_R3, V);
+          if (R.Type !== "normal") {
+            return UpdateEmpty(R, V);
           }
         }
       }
@@ -498,7 +499,7 @@ export function cook(rootAst, codeSource) {
     if (foundInB) {
       return NormalCompletion(V);
     }
-    var R = Evaluate(cases[defaultCaseIndex]);
+    const R = Evaluate(cases[defaultCaseIndex]);
     if (R.Value !== Empty) {
       V = R.Value;
     }
@@ -507,13 +508,13 @@ export function cook(rootAst, codeSource) {
     }
 
     // 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;
+    for (const C of B) {
+      const R = Evaluate(C);
+      if (R.Value !== Empty) {
+        V = R.Value;
       }
-      if (_R4.Type !== "normal") {
-        return UpdateEmpty(_R4, V);
+      if (R.Type !== "normal") {
+        return UpdateEmpty(R, V);
       }
     }
     return NormalCompletion(V);
@@ -521,21 +522,21 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
   function CaseClauseIsSelected(C, input) {
-    var clauseSelector = GetValue(Evaluate(C.test));
+    const clauseSelector = GetValue(Evaluate(C.test));
     return input === clauseSelector;
   }
 
   // While statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-whileloopevaluation
   function WhileLoopEvaluation(node) {
-    var V;
+    let V;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-      var exprValue = GetValue(Evaluate(node.test));
+      const exprValue = GetValue(Evaluate(node.test));
       if (!exprValue) {
         return NormalCompletion(V);
       }
-      var stmtResult = Evaluate(node.body);
+      const stmtResult = Evaluate(node.body);
       if (!LoopContinues(stmtResult)) {
         return UpdateEmpty(stmtResult, V);
       }
@@ -548,17 +549,17 @@ export function cook(rootAst, codeSource) {
   // Do-while Statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-dowhileloopevaluation
   function DoWhileLoopEvaluation(node) {
-    var V;
+    let V;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-      var stmtResult = Evaluate(node.body);
+      const stmtResult = Evaluate(node.body);
       if (!LoopContinues(stmtResult)) {
         return UpdateEmpty(stmtResult, V);
       }
       if (stmtResult.Value !== Empty) {
         V = stmtResult.Value;
       }
-      var exprValue = GetValue(Evaluate(node.test));
+      const exprValue = GetValue(Evaluate(node.test));
       if (!exprValue) {
         return NormalCompletion(V);
       }
@@ -568,12 +569,12 @@ export function cook(rootAst, codeSource) {
   // For in/of statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
   function ForInOfLoopEvaluation(node) {
-    var lhs = node.left;
-    var isVariableDeclaration = lhs.type === "VariableDeclaration";
-    var lhsKind = isVariableDeclaration ? lhs.kind === "var" ? "varBinding" : "lexicalBinding" : "assignment";
-    var uninitializedBoundNames = lhsKind === "lexicalBinding" ? collectBoundNames(lhs) : [];
-    var iterationKind = node.type === "ForInStatement" ? "enumerate" : "iterate";
-    var keyResult = ForInOfHeadEvaluation(uninitializedBoundNames, node.right, iterationKind);
+    const lhs = node.left;
+    const isVariableDeclaration = lhs.type === "VariableDeclaration";
+    const lhsKind = isVariableDeclaration ? lhs.kind === "var" ? "varBinding" : "lexicalBinding" : "assignment";
+    const uninitializedBoundNames = lhsKind === "lexicalBinding" ? 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;
@@ -583,71 +584,71 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
   function ForInOfHeadEvaluation(uninitializedBoundNames, expr, iterationKind) {
-    var runningContext = getRunningContext();
-    var oldEnv = runningContext.LexicalEnvironment;
+    const runningContext = getRunningContext();
+    const oldEnv = runningContext.LexicalEnvironment;
     if (uninitializedBoundNames.length > 0) {
-      var newEnv = new DeclarativeEnvironment(oldEnv);
-      for (var name of uninitializedBoundNames) {
+      const newEnv = new DeclarativeEnvironment(oldEnv);
+      for (const name of uninitializedBoundNames) {
         newEnv.CreateMutableBinding(name, false);
       }
       runningContext.LexicalEnvironment = newEnv;
     }
-    var exprRef = Evaluate(expr);
+    const exprRef = Evaluate(expr);
     runningContext.LexicalEnvironment = oldEnv;
-    var exprValue = GetValue(exprRef);
+    const exprValue = GetValue(exprRef);
     if (iterationKind === "enumerate") {
       if (exprValue === null || exprValue === undefined) {
         return new CompletionRecord("break", Empty);
       }
-      var _iterator = EnumerateObjectProperties(exprValue);
-      return NormalCompletion(_iterator);
+      const iterator = EnumerateObjectProperties(exprValue);
+      return NormalCompletion(iterator);
     }
-    var iterator = CreateListIteratorRecord(exprValue);
+    const 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;
+    const lhs = lhsKind === "assignment" ? node : node.declarations[0].id;
+    const oldEnv = getRunningContext().LexicalEnvironment;
+    let 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";
+    const destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern";
     // eslint-disable-next-line no-constant-condition
     while (true) {
-      var {
+      const {
         done,
         value: nextValue
       } = iteratorRecord.next();
       if (done) {
         return NormalCompletion(V);
       }
-      var lhsRef = void 0;
-      var iterationEnv = void 0;
+      let lhsRef;
+      let iterationEnv;
       if (lhsKind === "lexicalBinding") {
         iterationEnv = new DeclarativeEnvironment(oldEnv);
         ForDeclarationBindingInstantiation(node, iterationEnv);
         getRunningContext().LexicalEnvironment = iterationEnv;
         if (!destructuring) {
-          var [lhsName] = collectBoundNames(lhs);
+          const [lhsName] = collectBoundNames(lhs);
           lhsRef = ResolveBinding(lhsName);
         }
       } 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);
+      const result = Evaluate(stmt);
       getRunningContext().LexicalEnvironment = oldEnv;
       if (!LoopContinues(result)) {
-        var status = UpdateEmpty(result, V);
+        const status = UpdateEmpty(result, V);
         if (!(iterationKind === "enumerate" || iteratorRecord.return === undefined)) {
           // Perform *IteratorClose*
           // https://tc39.es/ecma262/#sec-iteratorclose
-          var innerResult = iteratorRecord.return();
+          const innerResult = iteratorRecord.return();
           if (!innerResult || !["object", "function"].includes(typeof innerResult)) {
-            throw new TypeError("Iterator result is not an object");
+            throw new TypeError(`Iterator result is not an object`);
           }
         }
         return status;
@@ -660,8 +661,8 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-enumerate-object-properties
   function* EnumerateObjectProperties(value) {
-    for (var _key in value) {
-      yield _key;
+    for (const key in value) {
+      yield key;
     }
   }
 
@@ -676,11 +677,11 @@ export function cook(rootAst, codeSource) {
         return ForBodyEvaluation(node.test, node.update, node.body, []);
       }
       // `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) {
+      const oldEnv = getRunningContext().LexicalEnvironment;
+      const loopEnv = new DeclarativeEnvironment(oldEnv);
+      const isConst = node.init.kind === "const";
+      const boundNames = collectBoundNames(node.init);
+      for (const dn of boundNames) {
         if (isConst) {
           loopEnv.CreateImmutableBinding(dn, true);
         } else {
@@ -689,14 +690,14 @@ export function cook(rootAst, codeSource) {
       }
       getRunningContext().LexicalEnvironment = loopEnv;
       Evaluate(node.init);
-      var perIterationLets = isConst ? [] : Array.from(boundNames);
-      var bodyResult = ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
+      const perIterationLets = isConst ? [] : Array.from(boundNames);
+      const bodyResult = ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
       getRunningContext().LexicalEnvironment = oldEnv;
       return bodyResult;
     }
     // `for ( … ; … ; … ) …`
     if (node.init) {
-      var exprRef = Evaluate(node.init);
+      const exprRef = Evaluate(node.init);
       GetValue(exprRef);
     }
     return ForBodyEvaluation(node.test, node.update, node.body, []);
@@ -705,17 +706,17 @@ export function cook(rootAst, codeSource) {
   // https://tc39.es/ecma262/#sec-forbodyevaluation
   function ForBodyEvaluation(test, increment, stmt, perIterationBindings) {
     CreatePerIterationEnvironment(perIterationBindings);
-    var V;
+    let V;
     // eslint-disable-next-line no-constant-condition
     while (true) {
       if (test) {
-        var testRef = Evaluate(test);
-        var testValue = GetValue(testRef);
+        const testRef = Evaluate(test);
+        const testValue = GetValue(testRef);
         if (!testValue) {
           return NormalCompletion(V);
         }
       }
-      var result = Evaluate(stmt);
+      const result = Evaluate(stmt);
       if (!LoopContinues(result)) {
         return UpdateEmpty(result, V);
       }
@@ -724,7 +725,7 @@ export function cook(rootAst, codeSource) {
       }
       CreatePerIterationEnvironment(perIterationBindings);
       if (increment) {
-        var incRef = Evaluate(increment);
+        const incRef = Evaluate(increment);
         GetValue(incRef);
       }
     }
@@ -735,12 +736,12 @@ export function cook(rootAst, codeSource) {
     if (perIterationBindings.length === 0) {
       return;
     }
-    var lastIterationEnv = getRunningContext().LexicalEnvironment;
-    var outer = lastIterationEnv.OuterEnv;
-    var thisIterationEnv = new DeclarativeEnvironment(outer);
-    for (var bn of perIterationBindings) {
+    const lastIterationEnv = getRunningContext().LexicalEnvironment;
+    const outer = lastIterationEnv.OuterEnv;
+    const thisIterationEnv = new DeclarativeEnvironment(outer);
+    for (const bn of perIterationBindings) {
       thisIterationEnv.CreateMutableBinding(bn, false);
-      var lastValue = lastIterationEnv.GetBindingValue(bn, false);
+      const lastValue = lastIterationEnv.GetBindingValue(bn, false);
       thisIterationEnv.InitializeBinding(bn, lastValue);
     }
     getRunningContext().LexicalEnvironment = thisIterationEnv;
@@ -756,23 +757,23 @@ export function cook(rootAst, codeSource) {
       }
       return NormalCompletion(Empty);
     }
-    var iteratorRecord = CreateListIteratorRecord(value);
+    const iteratorRecord = CreateListIteratorRecord(value);
     return IteratorDestructuringAssignmentEvaluation(pattern.elements, iteratorRecord);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-propertydestructuringassignmentevaluation
   function PropertyDestructuringAssignmentEvaluation(properties, value) {
-    var excludedNames = new Set();
-    for (var prop of properties) {
+    const excludedNames = new Set();
+    for (const 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;
+        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") {
-          var lref = ResolveBinding(valueTarget.name);
-          var v = GetV(value, propName);
+          const lref = ResolveBinding(valueTarget.name);
+          let v = GetV(value, propName);
           if (prop.value.type === "AssignmentPattern" && v === undefined) {
             // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-            var defaultValue = Evaluate(prop.value.right);
+            const defaultValue = Evaluate(prop.value.right);
             v = GetValue(defaultValue);
           }
           PutValue(lref, v);
@@ -789,17 +790,17 @@ export function cook(rootAst, codeSource) {
 
   // 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;
+    const assignmentTarget = node.type === "AssignmentPattern" ? node.left : node;
+    const isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
+    let lref;
     if (!isObjectOrArray) {
       lref = Evaluate(assignmentTarget).Value;
     }
-    var v = GetV(value, propertyName);
-    var rhsValue;
+    const v = GetV(value, propertyName);
+    let rhsValue;
     if (node.type === "AssignmentPattern" && v === undefined) {
       // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-      var defaultValue = Evaluate(node.right);
+      const defaultValue = Evaluate(node.right);
       rhsValue = GetValue(defaultValue);
     } else {
       rhsValue = v;
@@ -812,54 +813,54 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
   function RestDestructuringAssignmentEvaluation(restProperty, value, excludedNames) {
-    var lref = Evaluate(restProperty.argument).Value;
-    var restObj = CopyDataProperties({}, value, excludedNames);
+    const lref = Evaluate(restProperty.argument).Value;
+    const restObj = CopyDataProperties({}, value, excludedNames);
     return PutValue(lref, restObj);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
   function IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
-    var status = NormalCompletion(Empty);
-    for (var element of elements) {
+    let status = NormalCompletion(Empty);
+    for (const 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;
+      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;
       }
-      var v = void 0;
+      let v;
       if (element.type !== "RestElement") {
-        var {
+        const {
           done,
           value: nextValue
         } = iteratorRecord.next();
-        var _value2 = done ? undefined : nextValue;
-        if (element.type === "AssignmentPattern" && _value2 === undefined) {
+        const value = done ? undefined : nextValue;
+        if (element.type === "AssignmentPattern" && value === undefined) {
           // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-          var defaultValue = Evaluate(element.right);
+          const defaultValue = Evaluate(element.right);
           v = GetValue(defaultValue);
         } else {
-          v = _value2;
+          v = value;
         }
       } else {
         // RestElement
         v = [];
-        var n = 0;
+        let n = 0;
         // eslint-disable-next-line no-constant-condition
         while (true) {
-          var {
-            done: _done,
-            value: _nextValue
+          const {
+            done,
+            value: nextValue
           } = iteratorRecord.next();
-          if (_done) {
+          if (done) {
             break;
           }
-          v[n] = _nextValue;
+          v[n] = nextValue;
           n++;
         }
       }
@@ -875,28 +876,28 @@ export function cook(rootAst, codeSource) {
   // 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);
+    const propertyNameReference = Evaluate(expression);
+    const propertyNameValue = GetValue(propertyNameReference);
+    const propertyKey = ToPropertyKey(propertyNameValue);
     return new ReferenceRecord(baseValue, propertyKey, strict);
   }
 
   // https://tc39.es/ecma262/#sec-evaluate-property-access-with-identifier-key
   function EvaluatePropertyAccessWithIdentifierKey(baseValue, identifier, strict) {
-    var propertyNameString = identifier.name;
+    const propertyNameString = identifier.name;
     return new ReferenceRecord(baseValue, propertyNameString, strict);
   }
 
   // Block statements.
   // https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
   function BlockDeclarationInstantiation(code, env) {
-    var declarations = collectScopedDeclarations(code, {
+    const 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)) {
+    for (const d of declarations) {
+      const IsConstantDeclaration = d.type === "VariableDeclaration" && d.kind === "const";
+      for (const dn of collectBoundNames(d)) {
         if (IsConstantDeclaration) {
           env.CreateImmutableBinding(dn, true);
         } else {
@@ -904,9 +905,9 @@ export function cook(rootAst, codeSource) {
         }
       }
       if (d.type === "FunctionDeclaration") {
-        var [_fn] = collectBoundNames(d);
-        var _fo = InstantiateFunctionObject(d, env);
-        env.InitializeBinding(_fn, _fo);
+        const [fn] = collectBoundNames(d);
+        const fo = InstantiateFunctionObject(d, env);
+        env.InitializeBinding(fn, fo);
       }
     }
   }
@@ -914,45 +915,45 @@ export function cook(rootAst, codeSource) {
   // Function declarations and expressions.
   // https://tc39.es/ecma262/#sec-evaluatecall
   function EvaluateCall(func, ref, args, callee) {
-    var thisValue;
+    let thisValue;
     if (ref instanceof ReferenceRecord) {
       if (IsPropertyReference(ref)) {
         thisValue = ref.Base;
       }
     }
-    var argList = ArgumentListEvaluation(args);
+    const argList = ArgumentListEvaluation(args);
     if (typeof func !== "function") {
-      var funcName = codeSource.substring(callee.start, callee.end);
-      throw new TypeError("".concat(funcName, " is not a function"));
+      const funcName = codeSource.substring(callee.start, callee.end);
+      throw new TypeError(`${funcName} is not a function`);
     }
-    var result = func.apply(thisValue, argList);
+    const result = func.apply(thisValue, argList);
     sanitize(result);
     return NormalCompletion(result);
   }
 
   // https://tc39.es/ecma262/#sec-evaluatenew
   function EvaluateNew(constructExpr, args) {
-    var ref = Evaluate(constructExpr);
-    var constructor = GetValue(ref);
-    var argList = ArgumentListEvaluation(args);
+    const ref = Evaluate(constructExpr);
+    const constructor = GetValue(ref);
+    const 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"));
+      const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
+      throw new TypeError(`${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"));
+      const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
+      throw new TypeError(`${constructorName} is not an allowed constructor`);
     }
     return NormalCompletion(new constructor(...argList));
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
   function ArgumentListEvaluation(args) {
-    var array = [];
+    const array = [];
     if (Array.isArray(args)) {
-      for (var arg of args) {
+      for (const arg of args) {
         if (arg.type === "SpreadElement") {
-          var spreadValues = GetValue(Evaluate(arg.argument));
+          const spreadValues = GetValue(Evaluate(arg.argument));
           array.push(...spreadValues);
         } else {
           array.push(GetValue(Evaluate(arg)));
@@ -960,7 +961,7 @@ export function cook(rootAst, codeSource) {
       }
     } else {
       array.push(GetTemplateObject(args));
-      for (var expr of args.expressions) {
+      for (const expr of args.expressions) {
         array.push(GetValue(Evaluate(expr)));
       }
     }
@@ -972,7 +973,7 @@ export function cook(rootAst, codeSource) {
     var _hooks$beforeCall;
     (_hooks$beforeCall = hooks.beforeCall) === null || _hooks$beforeCall === void 0 || _hooks$beforeCall.call(hooks, closure[SourceNode]);
     PrepareForOrdinaryCall(closure);
-    var result = OrdinaryCallEvaluateBody(closure, args);
+    const result = OrdinaryCallEvaluateBody(closure, args);
     executionContextStack.pop();
     if (result.Type === "return") {
       return result.Value;
@@ -982,9 +983,9 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-prepareforordinarycall
   function PrepareForOrdinaryCall(F) {
-    var calleeContext = new ExecutionContext();
+    const calleeContext = new ExecutionContext();
     calleeContext.Function = F;
-    var localEnv = new FunctionEnvironment(F[Environment]);
+    const localEnv = new FunctionEnvironment(F[Environment]);
     calleeContext.VariableEnvironment = localEnv;
     calleeContext.LexicalEnvironment = localEnv;
     executionContextStack.push(calleeContext);
@@ -1007,9 +1008,9 @@ export function cook(rootAst, codeSource) {
 
   // 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);
+    let result = NormalCompletion(Empty);
+    for (const stmt of statements) {
+      const s = Evaluate(stmt);
       if (s.Type !== "normal") {
         return s;
       }
@@ -1020,47 +1021,47 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
   function FunctionDeclarationInstantiation(func, args) {
-    var calleeContext = getRunningContext();
-    var code = func[ECMAScriptCode];
-    var formals = func[FormalParameters];
-    var parameterNames = collectBoundNames(formals);
-    var hasParameterExpressions = containsExpression(formals);
-    var varDeclarations = collectScopedDeclarations(code, {
+    const calleeContext = getRunningContext();
+    const code = func[ECMAScriptCode];
+    const formals = func[FormalParameters];
+    const parameterNames = collectBoundNames(formals);
+    const hasParameterExpressions = containsExpression(formals);
+    const varDeclarations = collectScopedDeclarations(code, {
       var: true,
       topLevel: true
     });
-    var varNames = collectBoundNames(varDeclarations);
+    const varNames = collectBoundNames(varDeclarations);
 
     // `functionNames` ∈ `varNames`
     // `functionsToInitialize` ≈ `functionNames`
-    var functionNames = [];
-    var functionsToInitialize = [];
-    for (var i = varDeclarations.length - 1; i >= 0; i--) {
-      var d = varDeclarations[i];
+    const functionNames = [];
+    const functionsToInitialize = [];
+    for (let i = varDeclarations.length - 1; i >= 0; i--) {
+      const d = varDeclarations[i];
       if (d.type === "FunctionDeclaration") {
         ThrowIfFunctionIsInvalid(d);
-        var [_fn2] = collectBoundNames(d);
-        if (!functionNames.includes(_fn2)) {
-          functionNames.unshift(_fn2);
+        const [fn] = collectBoundNames(d);
+        if (!functionNames.includes(fn)) {
+          functionNames.unshift(fn);
           functionsToInitialize.unshift(d);
         }
       } else if (rules !== null && rules !== void 0 && rules.noVar) {
         throw new SyntaxError("Var declaration is not recommended, use `let` or `const` instead");
       }
     }
-    var env = calleeContext.LexicalEnvironment;
-    for (var paramName of parameterNames) {
+    const env = calleeContext.LexicalEnvironment;
+    for (const paramName of parameterNames) {
       // In strict mode, it's guaranteed no duplicate params exist.
       env.CreateMutableBinding(paramName, false);
     }
-    var iteratorRecord = CreateListIteratorRecord(args);
+    const iteratorRecord = CreateListIteratorRecord(args);
     IteratorBindingInitialization(formals, iteratorRecord, env);
-    var varEnv;
+    let varEnv;
     if (!hasParameterExpressions) {
       // NOTE: Only a single Environment Record is needed for the parameters
       // and top-level vars.
       // `varNames` are unique.
-      for (var n of varNames) {
+      for (const n of varNames) {
         if (!parameterNames.includes(n)) {
           env.CreateMutableBinding(n, false);
           env.InitializeBinding(n, undefined);
@@ -1074,37 +1075,37 @@ export function cook(rootAst, codeSource) {
       varEnv = new DeclarativeEnvironment(env);
       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);
+      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);
+        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.
       }
     }
-    var lexEnv = varEnv;
+    const lexEnv = varEnv;
     calleeContext.LexicalEnvironment = lexEnv;
-    var lexDeclarations = collectScopedDeclarations(code, {
+    const lexDeclarations = collectScopedDeclarations(code, {
       var: false,
       topLevel: true
     });
-    for (var _d of lexDeclarations) {
-      for (var dn of collectBoundNames(_d)) {
+    for (const d of lexDeclarations) {
+      for (const dn of collectBoundNames(d)) {
         // Only lexical VariableDeclaration here in top-level.
-        if (_d.kind === "const") {
+        if (d.kind === "const") {
           lexEnv.CreateImmutableBinding(dn, true);
         } else {
           lexEnv.CreateMutableBinding(dn, false);
         }
       }
     }
-    for (var f of functionsToInitialize) {
-      var [_fn3] = collectBoundNames(f);
-      var _fo2 = InstantiateFunctionObject(f, lexEnv);
-      varEnv.SetMutableBinding(_fn3, _fo2, false);
+    for (const f of functionsToInitialize) {
+      const [fn] = collectBoundNames(f);
+      const fo = InstantiateFunctionObject(f, lexEnv);
+      varEnv.SetMutableBinding(fn, fo, false);
     }
   }
 
@@ -1115,30 +1116,30 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
   function InstantiateOrdinaryFunctionExpression(functionExpression) {
-    var scope = getRunningContext().LexicalEnvironment;
+    const scope = getRunningContext().LexicalEnvironment;
     if (functionExpression.id) {
-      var name = functionExpression.id.name;
-      var funcEnv = new DeclarativeEnvironment(scope);
+      const name = functionExpression.id.name;
+      const funcEnv = new DeclarativeEnvironment(scope);
       funcEnv.CreateImmutableBinding(name, false);
-      var closure = OrdinaryFunctionCreate(functionExpression, funcEnv, true);
+      const closure = OrdinaryFunctionCreate(functionExpression, funcEnv, true);
       funcEnv.InitializeBinding(name, closure);
       return closure;
     } else {
-      var _closure = OrdinaryFunctionCreate(functionExpression, scope, true);
-      return _closure;
+      const closure = OrdinaryFunctionCreate(functionExpression, scope, true);
+      return closure;
     }
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression
   function InstantiateArrowFunctionExpression(arrowFunction) {
-    var scope = getRunningContext().LexicalEnvironment;
-    var closure = OrdinaryFunctionCreate(arrowFunction, scope, false);
+    const scope = getRunningContext().LexicalEnvironment;
+    const closure = OrdinaryFunctionCreate(arrowFunction, scope, false);
     return closure;
   }
 
   // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
   function OrdinaryFunctionCreate(sourceNode, scope, isConstructor) {
-    var F = function () {
+    const F = function () {
       // eslint-disable-next-line prefer-rest-params
       return CallFunction(F, arguments);
     };
@@ -1173,7 +1174,7 @@ export function cook(rootAst, codeSource) {
         return PropertyBindingInitialization(node.properties, value, environment);
       case "ArrayPattern":
         {
-          var iteratorRecord = CreateListIteratorRecord(value);
+          const iteratorRecord = CreateListIteratorRecord(value);
           return IteratorBindingInitialization(node.elements, iteratorRecord, environment);
         }
     }
@@ -1181,8 +1182,8 @@ export function cook(rootAst, codeSource) {
 
   // 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) {
+    const excludedNames = new Set();
+    for (const prop of properties) {
       if (prop.type === "RestElement") {
         return RestBindingInitialization(prop, value, environment, excludedNames);
       }
@@ -1190,7 +1191,7 @@ export function cook(rootAst, codeSource) {
         KeyedBindingInitialization(prop.value, value, environment, prop.key.name);
         excludedNames.add(prop.key.name);
       } else {
-        var P = EvaluateComputedPropertyName(prop.key);
+        const P = EvaluateComputedPropertyName(prop.key);
         KeyedBindingInitialization(prop.value, value, environment, P);
         excludedNames.add(P);
       }
@@ -1200,14 +1201,14 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#prod-ComputedPropertyName
   function EvaluateComputedPropertyName(node) {
-    var propName = GetValue(Evaluate(node));
+    const propName = GetValue(Evaluate(node));
     return ToPropertyKey(propName);
   }
 
   // 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);
+    const lhs = ResolveBinding(restProperty.argument.name, environment);
+    const restObj = CopyDataProperties({}, value, excludedNames);
     if (!environment) {
       return PutValue(lhs, restObj);
     }
@@ -1219,65 +1220,65 @@ export function cook(rootAst, codeSource) {
     if (elements.length === 0) {
       return NormalCompletion(Empty);
     }
-    var result;
-    for (var _node of elements) {
-      if (!_node) {
+    let result;
+    for (const node of elements) {
+      if (!node) {
         // Elision element.
         iteratorRecord.next();
         result = NormalCompletion(Empty);
-      } else if (_node.type === "RestElement") {
+      } else if (node.type === "RestElement") {
         // Rest element.
-        if (_node.argument.type === "Identifier") {
-          var lhs = ResolveBinding(_node.argument.name, environment);
-          var A = [];
-          var n = 0;
+        if (node.argument.type === "Identifier") {
+          const lhs = ResolveBinding(node.argument.name, environment);
+          const A = [];
+          let n = 0;
           // eslint-disable-next-line no-constant-condition
           while (true) {
-            var {
+            const {
               done,
-              value: _value3
+              value
             } = iteratorRecord.next();
             if (done) {
               result = environment ? InitializeReferencedBinding(lhs, A) : PutValue(lhs, A);
               break;
             }
-            A[n] = _value3;
+            A[n] = value;
             n++;
           }
         } else {
-          var _A = [];
-          var _n2 = 0;
+          const A = [];
+          let n = 0;
           // eslint-disable-next-line no-constant-condition
           while (true) {
-            var {
-              done: _done2,
-              value: _value4
+            const {
+              done,
+              value
             } = iteratorRecord.next();
-            if (_done2) {
-              result = BindingInitialization(_node.argument, _A, environment);
+            if (done) {
+              result = BindingInitialization(node.argument, A, environment);
               break;
             }
-            _A[_n2] = _value4;
-            _n2++;
+            A[n] = value;
+            n++;
           }
         }
       } else {
         // Normal element.
-        var bindingElement = _node.type === "AssignmentPattern" ? _node.left : _node;
+        const bindingElement = node.type === "AssignmentPattern" ? node.left : node;
         switch (bindingElement.type) {
           case "ObjectPattern":
           case "ArrayPattern":
             {
-              var v = void 0;
-              var {
-                done: _done3,
-                value: _value5
+              let v;
+              const {
+                done,
+                value
               } = iteratorRecord.next();
-              if (!_done3) {
-                v = _value5;
+              if (!done) {
+                v = value;
               }
-              if (_node.type === "AssignmentPattern" && v === undefined) {
-                var defaultValue = Evaluate(_node.right);
+              if (node.type === "AssignmentPattern" && v === undefined) {
+                const defaultValue = Evaluate(node.right);
                 v = GetValue(defaultValue);
               }
               result = BindingInitialization(bindingElement, v, environment);
@@ -1285,22 +1286,22 @@ export function cook(rootAst, codeSource) {
             }
           case "Identifier":
             {
-              var bindingId = bindingElement.name;
-              var _lhs3 = ResolveBinding(bindingId, environment);
-              var _v = void 0;
-              var {
-                done: _done4,
-                value: _value6
+              const bindingId = bindingElement.name;
+              const lhs = ResolveBinding(bindingId, environment);
+              let v;
+              const {
+                done,
+                value
               } = iteratorRecord.next();
-              if (!_done4) {
-                _v = _value6;
+              if (!done) {
+                v = value;
               }
-              if (_node.type === "AssignmentPattern" && _v === undefined) {
+              if (node.type === "AssignmentPattern" && v === undefined) {
                 // IsAnonymousFunctionDefinition(Initializer)
-                var _defaultValue = Evaluate(_node.right);
-                _v = GetValue(_defaultValue);
+                const defaultValue = Evaluate(node.right);
+                v = GetValue(defaultValue);
               }
-              result = environment ? InitializeReferencedBinding(_lhs3, _v) : PutValue(_lhs3, _v);
+              result = environment ? InitializeReferencedBinding(lhs, v) : PutValue(lhs, v);
               break;
             }
         }
@@ -1311,25 +1312,25 @@ export function cook(rootAst, codeSource) {
 
   // 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";
+    const 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) {
+      const bindingId = node.type === "Identifier" ? node.name : node.left.name;
+      const lhs = ResolveBinding(bindingId, environment);
+      let v = GetV(value, propertyName);
+      if (node.type === "AssignmentPattern" && v === undefined) {
         // If IsAnonymousFunctionDefinition(Initializer)
-        var defaultValue = Evaluate(node.right);
-        _v2 = GetValue(defaultValue);
+        const defaultValue = Evaluate(node.right);
+        v = GetValue(defaultValue);
       }
       if (!environment) {
-        return PutValue(lhs, _v2);
+        return PutValue(lhs, v);
       }
-      return InitializeReferencedBinding(lhs, _v2);
+      return InitializeReferencedBinding(lhs, v);
     }
-    var v = GetV(value, propertyName);
+    let v = GetV(value, propertyName);
     if (node.type === "AssignmentPattern" && v === undefined) {
-      var _defaultValue2 = Evaluate(node.right);
-      v = GetValue(_defaultValue2);
+      const defaultValue = Evaluate(node.right);
+      v = GetValue(defaultValue);
     }
     return BindingInitialization(node.type === "AssignmentPattern" ? node.left : node, v, environment);
   }
@@ -1342,7 +1343,7 @@ export function cook(rootAst, codeSource) {
   }
   function ThrowIfFunctionIsInvalid(func) {
     if (func.async || func.generator) {
-      throw new SyntaxError("".concat(func.async ? "Async" : "Generator", " function is not allowed"));
+      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");
@@ -1353,10 +1354,10 @@ export function cook(rootAst, codeSource) {
   }
   (_hooks$beforeEvaluate3 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate3 === void 0 || _hooks$beforeEvaluate3.call(hooks, rootAst);
   ThrowIfFunctionIsInvalid(rootAst);
-  var [fn] = collectBoundNames(rootAst);
+  const [fn] = collectBoundNames(rootAst);
   // Create an immutable binding for the root function.
   rootEnv.CreateImmutableBinding(fn, true);
-  var fo = InstantiateFunctionObject(rootAst, rootEnv);
+  const fo = InstantiateFunctionObject(rootAst, rootEnv);
   rootEnv.InitializeBinding(fn, fo);
   return fo;
 }