@next-core/cook 2.2.18 → 2.4.0

package/dist/cjs/cook.js

@@ -11,11 +11,20 @@ var _traverse = require("./traverse.js");
 /** For next-core internal usage only. */
 function cook(rootAst, codeSource, {
   rules,
+  debug,
+  externalSourceForDebug,
   globalVariables = {},
+  // Allow debugger to override Array constructor.
+  ArrayConstructor = Array,
   hooks = {}
 } = {}) {
   var _hooks$beforeEvaluate3;
   const expressionOnly = rootAst.type !== "FunctionDeclaration";
+  function doSanitize(cooked) {
+    if (!externalSourceForDebug) {
+      (0, _sanitize.sanitize)(cooked);
+    }
+  }
   const rootEnv = new _ExecutionContext.DeclarativeEnvironment(null);
   const rootContext = new _ExecutionContext.ExecutionContext();
   rootContext.VariableEnvironment = rootEnv;
@@ -46,23 +55,28 @@ function cook(rootAst, codeSource, {
     TemplateMap.set(templateLiteral, template);
     return template;
   }
-  function Evaluate(node, optionalChainRef) {
-    var _hooks$beforeEvaluate, _hooks$beforeBranch, _hooks$beforeBranch2;
+  let currentNode;
+  function* Evaluate(node, optionalChainRef, forceYield) {
+    var _hooks$beforeEvaluate, _hooks$beforeBranch2;
     (_hooks$beforeEvaluate = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate === void 0 || _hooks$beforeEvaluate.call(hooks, node);
+    currentNode = node;
+    if (debug && (forceYield || node.type.endsWith("Statement") && node.type !== "TryStatement" && node.type !== "BlockStatement" && node.type !== "ForStatement" && node.type !== "ForInStatement" && node.type !== "ForOfStatement")) {
+      yield;
+    }
     // Expressions:
     switch (node.type) {
       case "ArrayExpression":
         {
           // https://tc39.es/ecma262/#sec-array-initializer
-          const array = [];
+          const array = new ArrayConstructor();
           for (const element of node.elements) {
             if (!element) {
               array.length += 1;
             } else if (element.type === "SpreadElement") {
-              const spreadValues = (0, _contextFree.GetValue)(Evaluate(element.argument));
+              const spreadValues = (0, _contextFree.GetValue)(yield* Evaluate(element.argument));
               array.push(...spreadValues);
             } else {
-              array.push((0, _contextFree.GetValue)(Evaluate(element)));
+              array.push((0, _contextFree.GetValue)(yield* Evaluate(element)));
             }
           }
           return (0, _ExecutionContext.NormalCompletion)(array);
@@ -76,9 +90,9 @@ function cook(rootAst, codeSource, {
         }
       case "BinaryExpression":
         {
-          const leftRef = Evaluate(node.left);
+          const leftRef = yield* Evaluate(node.left);
           const leftValue = (0, _contextFree.GetValue)(leftRef);
-          const rightRef = Evaluate(node.right).Value;
+          const rightRef = yield* Evaluate(node.right);
           const rightValue = (0, _contextFree.GetValue)(rightRef);
           if (expressionOnly && node.operator === "|>") {
             // Minimal pipeline operator is supported only in expression-only mode.
@@ -103,21 +117,22 @@ function cook(rootAst, codeSource, {
       case "CallExpression":
         {
           // https://tc39.es/ecma262/#sec-function-calls
-          const ref = Evaluate(node.callee, optionalChainRef).Value;
+          const ref = (yield* Evaluate(node.callee, optionalChainRef)).Value;
           const func = (0, _contextFree.GetValue)(ref);
           if ((func === undefined || func === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return (0, _ExecutionContext.NormalCompletion)(undefined);
           }
-          (0, _sanitize.sanitize)(func);
-          return EvaluateCall(func, ref, node.arguments, node.callee);
+          doSanitize(func);
+          if (debug) yield;
+          return yield* EvaluateCall(func, ref, node.arguments, node.callee);
         }
       case "ChainExpression":
         // https://tc39.es/ecma262/#sec-optional-chains
-        return Evaluate(node.expression, {});
+        return yield* Evaluate(node.expression, {});
       case "ConditionalExpression":
         // https://tc39.es/ecma262/#sec-conditional-operator
-        return (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(Evaluate((0, _contextFree.GetValue)(Evaluate(node.test)) ? node.consequent : node.alternate)));
+        return (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(yield* Evaluate((0, _contextFree.GetValue)(yield* Evaluate(node.test)) ? node.consequent : node.alternate)));
       case "Identifier":
         // https://tc39.es/ecma262/#sec-identifiers
         return (0, _ExecutionContext.NormalCompletion)(ResolveBinding(node.name));
@@ -139,14 +154,14 @@ function cook(rootAst, codeSource, {
       case "LogicalExpression":
         {
           // https://tc39.es/ecma262/#sec-binary-logical-operators
-          const leftValue = (0, _contextFree.GetValue)(Evaluate(node.left));
+          const leftValue = (0, _contextFree.GetValue)(yield* Evaluate(node.left));
           switch (node.operator) {
             case "&&":
-              return (0, _ExecutionContext.NormalCompletion)(leftValue && (0, _contextFree.GetValue)(Evaluate(node.right)));
+              return (0, _ExecutionContext.NormalCompletion)(leftValue && (0, _contextFree.GetValue)(yield* Evaluate(node.right)));
             case "||":
-              return (0, _ExecutionContext.NormalCompletion)(leftValue || (0, _contextFree.GetValue)(Evaluate(node.right)));
+              return (0, _ExecutionContext.NormalCompletion)(leftValue || (0, _contextFree.GetValue)(yield* Evaluate(node.right)));
             case "??":
-              return (0, _ExecutionContext.NormalCompletion)(leftValue ?? (0, _contextFree.GetValue)(Evaluate(node.right)));
+              return (0, _ExecutionContext.NormalCompletion)(leftValue ?? (0, _contextFree.GetValue)(yield* Evaluate(node.right)));
             // istanbul ignore next
             default:
               throw new SyntaxError(
@@ -158,37 +173,41 @@ function cook(rootAst, codeSource, {
       case "MemberExpression":
         {
           // https://tc39.es/ecma262/#sec-property-accessors
-          const baseReference = Evaluate(node.object, optionalChainRef).Value;
+          const baseReference = (yield* Evaluate(node.object, optionalChainRef)).Value;
           const baseValue = (0, _contextFree.GetValue)(baseReference);
           if ((baseValue === undefined || baseValue === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return (0, _ExecutionContext.NormalCompletion)(undefined);
           }
-          (0, _sanitize.sanitize)(baseValue);
-          const result = node.computed ? EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
-          (0, _sanitize.sanitize)(result);
+          doSanitize(baseValue);
+          const result = node.computed ? yield* EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
+          doSanitize(result);
           return (0, _ExecutionContext.NormalCompletion)(result);
         }
       case "NewExpression":
         // https://tc39.es/ecma262/#sec-new-operator
-        return EvaluateNew(node.callee, node.arguments);
+        return yield* EvaluateNew(node.callee, node.arguments);
       case "ObjectExpression":
         {
           // https://tc39.es/ecma262/#sec-object-initializer
           const object = {};
           for (const prop of node.properties) {
             if (prop.type === "SpreadElement") {
-              const fromValue = (0, _contextFree.GetValue)(Evaluate(prop.argument));
+              const fromValue = (0, _contextFree.GetValue)(yield* Evaluate(prop.argument));
               (0, _contextFree.CopyDataProperties)(object, fromValue, new Set());
             } else {
               if (prop.kind !== "init") {
                 throw new SyntaxError("Unsupported object getter/setter");
               }
-              const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : EvaluateComputedPropertyName(prop.key);
+              const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : yield* EvaluateComputedPropertyName(prop.key);
               if (propName === "__proto__") {
                 throw new TypeError("Setting '__proto__' property is not allowed");
               }
-              object[propName] = (0, _contextFree.GetValue)(Evaluate(prop.value));
+              const propValue = (0, _contextFree.GetValue)(yield* Evaluate(prop.value));
+              if (prop.method && typeof propValue === "function") {
+                SetFunctionName(propValue, propName);
+              }
+              object[propName] = propValue;
             }
           }
           return (0, _ExecutionContext.NormalCompletion)(object);
@@ -198,7 +217,7 @@ function cook(rootAst, codeSource, {
           // https://tc39.es/ecma262/#sec-comma-operator
           let result;
           for (const expr of node.expressions) {
-            result = (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(Evaluate(expr)));
+            result = (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(yield* Evaluate(expr)));
           }
           return result;
         }
@@ -208,7 +227,7 @@ function cook(rootAst, codeSource, {
           const chunks = [node.quasis[0].value.cooked];
           let index = 0;
           for (const expr of node.expressions) {
-            const val = (0, _contextFree.GetValue)(Evaluate(expr));
+            const val = (0, _contextFree.GetValue)(yield* Evaluate(expr));
             chunks.push(String(val));
             chunks.push(node.quasis[index += 1].value.cooked);
           }
@@ -217,15 +236,16 @@ function cook(rootAst, codeSource, {
       case "TaggedTemplateExpression":
         {
           // https://tc39.es/ecma262/#sec-tagged-templates
-          const tagRef = Evaluate(node.tag).Value;
+          const tagRef = (yield* Evaluate(node.tag)).Value;
           const tagFunc = (0, _contextFree.GetValue)(tagRef);
-          (0, _sanitize.sanitize)(tagFunc);
-          return EvaluateCall(tagFunc, tagRef, node.quasi, node.tag);
+          doSanitize(tagFunc);
+          if (debug) yield;
+          return yield* EvaluateCall(tagFunc, tagRef, node.quasi, node.tag);
         }
       case "UnaryExpression":
         {
           // https://tc39.es/ecma262/#sec-unary-operators
-          const ref = Evaluate(node.argument).Value;
+          const ref = (yield* Evaluate(node.argument)).Value;
           if (!expressionOnly && node.operator === "delete") {
             // Delete operator is supported only in function mode.
             if (!(ref instanceof _ExecutionContext.ReferenceRecord)) {
@@ -255,22 +275,26 @@ function cook(rootAst, codeSource, {
             // https://tc39.es/ecma262/#sec-assignment-operators
             if (node.operator === "=") {
               if (!(node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern")) {
-                const lref = Evaluate(node.left).Value;
-                // Todo: IsAnonymousFunctionDefinition(lref)
-                const rref = Evaluate(node.right);
-                const rval = (0, _contextFree.GetValue)(rref);
+                const lref = (yield* Evaluate(node.left)).Value;
+                let rval;
+                if (IsAnonymousFunctionDefinition(node.right) && node.left.type === "Identifier") {
+                  rval = NamedEvaluation(node.right, node.left.name);
+                } else {
+                  const rref = yield* Evaluate(node.right);
+                  rval = (0, _contextFree.GetValue)(rref);
+                }
                 (0, _contextFree.PutValue)(lref, rval);
                 return (0, _ExecutionContext.NormalCompletion)(rval);
               }
-              const rref = Evaluate(node.right);
+              const rref = yield* Evaluate(node.right);
               const rval = (0, _contextFree.GetValue)(rref);
-              DestructuringAssignmentEvaluation(node.left, rval);
+              yield* DestructuringAssignmentEvaluation(node.left, rval);
               return (0, _ExecutionContext.NormalCompletion)(rval);
             }
             // Operators other than `=`.
-            const lref = Evaluate(node.left).Value;
+            const lref = (yield* Evaluate(node.left)).Value;
             const lval = (0, _contextFree.GetValue)(lref);
-            const rref = Evaluate(node.right);
+            const rref = yield* Evaluate(node.right);
             const rval = (0, _contextFree.GetValue)(rref);
             const r = (0, _contextFree.ApplyStringOrNumericAssignment)(lval, node.operator, rval);
             (0, _contextFree.PutValue)(lref, r);
@@ -286,7 +310,7 @@ function cook(rootAst, codeSource, {
             const blockEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
             BlockDeclarationInstantiation(node.body, blockEnv);
             getRunningContext().LexicalEnvironment = blockEnv;
-            const blockValue = EvaluateStatementList(node.body);
+            const blockValue = yield* EvaluateStatementList(node.body);
             getRunningContext().LexicalEnvironment = oldEnv;
             return blockValue;
           }
@@ -301,18 +325,18 @@ function cook(rootAst, codeSource, {
           return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
         case "DoWhileStatement":
           // https://tc39.es/ecma262/#sec-do-while-statement
-          return EvaluateBreakableStatement(DoWhileLoopEvaluation(node));
+          return EvaluateBreakableStatement(yield* DoWhileLoopEvaluation(node));
         case "ExpressionStatement":
         case "TSAsExpression":
           // https://tc39.es/ecma262/#sec-expression-statement
-          return Evaluate(node.expression);
+          return yield* Evaluate(node.expression);
         case "ForInStatement":
         case "ForOfStatement":
           // https://tc39.es/ecma262/#sec-for-in-and-for-of-statements
-          return EvaluateBreakableStatement(ForInOfLoopEvaluation(node));
+          return EvaluateBreakableStatement(yield* ForInOfLoopEvaluation(node));
         case "ForStatement":
           // https://tc39.es/ecma262/#sec-for-statement
-          return EvaluateBreakableStatement(ForLoopEvaluation(node));
+          return EvaluateBreakableStatement(yield* ForLoopEvaluation(node));
         case "FunctionDeclaration":
           // https://tc39.es/ecma262/#sec-function-definitions
           return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
@@ -322,41 +346,58 @@ function cook(rootAst, codeSource, {
           return (0, _ExecutionContext.NormalCompletion)(InstantiateOrdinaryFunctionExpression(node));
         case "IfStatement":
           // https://tc39.es/ecma262/#sec-if-statement
-          return (0, _contextFree.GetValue)(Evaluate(node.test)) ? ((_hooks$beforeBranch = hooks.beforeBranch) !== null && _hooks$beforeBranch !== void 0 && _hooks$beforeBranch.call(hooks, node, "if"), (0, _contextFree.UpdateEmpty)(Evaluate(node.consequent), undefined)) : ((_hooks$beforeBranch2 = hooks.beforeBranch) !== null && _hooks$beforeBranch2 !== void 0 && _hooks$beforeBranch2.call(hooks, node, "else"), node.alternate) ? (0, _contextFree.UpdateEmpty)(Evaluate(node.alternate), undefined) : (0, _ExecutionContext.NormalCompletion)(undefined);
+          if ((0, _contextFree.GetValue)(yield* Evaluate(node.test))) {
+            var _hooks$beforeBranch;
+            (_hooks$beforeBranch = hooks.beforeBranch) === null || _hooks$beforeBranch === void 0 || _hooks$beforeBranch.call(hooks, node, "if");
+            return (0, _contextFree.UpdateEmpty)(yield* Evaluate(node.consequent), undefined);
+          }
+          (_hooks$beforeBranch2 = hooks.beforeBranch) === null || _hooks$beforeBranch2 === void 0 || _hooks$beforeBranch2.call(hooks, node, "else");
+          if (node.alternate) {
+            return (0, _contextFree.UpdateEmpty)(yield* Evaluate(node.alternate), undefined);
+          }
+          return (0, _ExecutionContext.NormalCompletion)(undefined);
         case "ReturnStatement":
           {
             // https://tc39.es/ecma262/#sec-return-statement
             let v;
             if (node.argument) {
-              const exprRef = Evaluate(node.argument);
+              const exprRef = yield* Evaluate(node.argument);
               v = (0, _contextFree.GetValue)(exprRef);
             }
             return new _ExecutionContext.CompletionRecord("return", v);
           }
+        case "ThisExpression":
+          {
+            if (!externalSourceForDebug) {
+              break;
+            }
+            const envRec = GetThisEnvironment();
+            return (0, _ExecutionContext.NormalCompletion)(envRec.GetThisBinding());
+          }
         case "ThrowStatement":
           // https://tc39.es/ecma262/#sec-throw-statement
-          throw (0, _contextFree.GetValue)(Evaluate(node.argument));
+          throw (0, _contextFree.GetValue)(yield* Evaluate(node.argument));
         case "UpdateExpression":
           {
             // https://tc39.es/ecma262/#sec-update-expressions
-            const lhs = Evaluate(node.argument).Value;
+            const lhs = (yield* Evaluate(node.argument)).Value;
             const oldValue = Number((0, _contextFree.GetValue)(lhs));
             const newValue = node.operator === "++" ? oldValue + 1 : oldValue - 1;
             (0, _contextFree.PutValue)(lhs, newValue);
             return (0, _ExecutionContext.NormalCompletion)(node.prefix ? newValue : oldValue);
           }
         case "SwitchCase":
-          return EvaluateStatementList(node.consequent);
+          return yield* EvaluateStatementList(node.consequent);
         case "SwitchStatement":
           {
             // https://tc39.es/ecma262/#sec-switch-statement
-            const exprRef = Evaluate(node.discriminant);
+            const exprRef = yield* Evaluate(node.discriminant);
             const switchValue = (0, _contextFree.GetValue)(exprRef);
             const oldEnv = getRunningContext().LexicalEnvironment;
             const blockEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
             BlockDeclarationInstantiation(node.cases, blockEnv);
             getRunningContext().LexicalEnvironment = blockEnv;
-            const R = CaseBlockEvaluation(node.cases, switchValue);
+            const R = yield* CaseBlockEvaluation(node.cases, switchValue);
             getRunningContext().LexicalEnvironment = oldEnv;
             return EvaluateBreakableStatement(R);
           }
@@ -365,18 +406,19 @@ function cook(rootAst, codeSource, {
             // https://tc39.es/ecma262/#sec-try-statement
             let R;
             try {
-              R = Evaluate(node.block);
+              R = yield* Evaluate(node.block);
             } catch (error) {
               if (node.handler) {
                 var _hooks$beforeEvaluate2;
+                currentNode = node.handler;
                 (_hooks$beforeEvaluate2 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate2 === void 0 || _hooks$beforeEvaluate2.call(hooks, node.handler);
-                R = CatchClauseEvaluation(node.handler, error);
+                R = yield* CatchClauseEvaluation(node.handler, error);
               } else {
                 throw error;
               }
             } finally {
               if (node.finalizer) {
-                const F = Evaluate(node.finalizer);
+                const F = yield* Evaluate(node.finalizer);
                 if (F.Type !== "normal") {
                   R = F;
                 }
@@ -389,6 +431,7 @@ function cook(rootAst, codeSource, {
             // https://tc39.es/ecma262/#sec-declarations-and-the-variable-statement
             let result;
             for (const declarator of node.declarations) {
+              currentNode = declarator;
               if (!declarator.init) {
                 // Assert: a declarator without init is always an identifier.
                 if (node.kind === "var") {
@@ -398,23 +441,31 @@ function cook(rootAst, codeSource, {
                   result = (0, _contextFree.InitializeReferencedBinding)(lhs, undefined);
                 }
               } else if (declarator.id.type === "Identifier") {
+                currentNode = declarator.init;
+                if (debug) yield;
                 const bindingId = declarator.id.name;
                 const lhs = ResolveBinding(bindingId);
-                // Todo: IsAnonymousFunctionDefinition(Initializer)
-                const rhs = Evaluate(declarator.init);
-                const value = (0, _contextFree.GetValue)(rhs);
+                let value;
+                if (IsAnonymousFunctionDefinition(declarator.init)) {
+                  value = NamedEvaluation(declarator.init, bindingId);
+                } else {
+                  const rhs = yield* Evaluate(declarator.init);
+                  value = (0, _contextFree.GetValue)(rhs);
+                }
                 result = node.kind === "var" ? (0, _contextFree.PutValue)(lhs, value) : (0, _contextFree.InitializeReferencedBinding)(lhs, value);
               } else {
-                const rhs = Evaluate(declarator.init);
+                currentNode = declarator.init;
+                if (debug) yield;
+                const rhs = yield* Evaluate(declarator.init);
                 const rval = (0, _contextFree.GetValue)(rhs);
-                result = BindingInitialization(declarator.id, rval, node.kind === "var" ? undefined : getRunningContext().LexicalEnvironment);
+                result = yield* BindingInitialization(declarator.id, rval, node.kind === "var" ? undefined : getRunningContext().LexicalEnvironment);
               }
             }
             return result;
           }
         case "WhileStatement":
           // https://tc39.es/ecma262/#sec-while-statement
-          return EvaluateBreakableStatement(WhileLoopEvaluation(node));
+          return EvaluateBreakableStatement(yield* WhileLoopEvaluation(node));
       }
     }
     // eslint-disable-next-line no-console
@@ -436,9 +487,9 @@ function cook(rootAst, codeSource, {
 
   // Try statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation
-  function CatchClauseEvaluation(node, thrownValue) {
+  function* CatchClauseEvaluation(node, thrownValue) {
     if (!node.param) {
-      return Evaluate(node.body);
+      return yield* Evaluate(node.body);
     }
     const oldEnv = getRunningContext().LexicalEnvironment;
     const catchEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
@@ -446,8 +497,8 @@ function cook(rootAst, codeSource, {
       catchEnv.CreateMutableBinding(argName, false);
     }
     getRunningContext().LexicalEnvironment = catchEnv;
-    BindingInitialization(node.param, thrownValue, catchEnv);
-    const B = Evaluate(node.body);
+    yield* BindingInitialization(node.param, thrownValue, catchEnv);
+    const B = yield* Evaluate(node.body);
     getRunningContext().LexicalEnvironment = oldEnv;
     return B;
   }
@@ -460,7 +511,7 @@ function cook(rootAst, codeSource, {
 
   // Switch statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
-  function CaseBlockEvaluation(cases, input) {
+  function* CaseBlockEvaluation(cases, input) {
     let V;
     const defaultCaseIndex = cases.findIndex(switchCase => !switchCase.test);
     const hasDefaultCase = defaultCaseIndex >= 0;
@@ -468,10 +519,10 @@ function cook(rootAst, codeSource, {
     let found = false;
     for (const C of A) {
       if (!found) {
-        found = CaseClauseIsSelected(C, input);
+        found = yield* CaseClauseIsSelected(C, input);
       }
       if (found) {
-        const R = Evaluate(C);
+        const R = yield* Evaluate(C);
         if (R.Value !== _ExecutionContext.Empty) {
           V = R.Value;
         }
@@ -488,10 +539,10 @@ function cook(rootAst, codeSource, {
     if (!found) {
       for (const C of B) {
         if (!foundInB) {
-          foundInB = CaseClauseIsSelected(C, input);
+          foundInB = yield* CaseClauseIsSelected(C, input);
         }
         if (foundInB) {
-          const R = Evaluate(C);
+          const R = yield* Evaluate(C);
           if (R.Value !== _ExecutionContext.Empty) {
             V = R.Value;
           }
@@ -504,7 +555,7 @@ function cook(rootAst, codeSource, {
     if (foundInB) {
       return (0, _ExecutionContext.NormalCompletion)(V);
     }
-    const R = Evaluate(cases[defaultCaseIndex]);
+    const R = yield* Evaluate(cases[defaultCaseIndex]);
     if (R.Value !== _ExecutionContext.Empty) {
       V = R.Value;
     }
@@ -514,7 +565,7 @@ function cook(rootAst, codeSource, {
 
     // NOTE: The following is another complete iteration of the second CaseClauses.
     for (const C of B) {
-      const R = Evaluate(C);
+      const R = yield* Evaluate(C);
       if (R.Value !== _ExecutionContext.Empty) {
         V = R.Value;
       }
@@ -526,22 +577,22 @@ function cook(rootAst, codeSource, {
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
-  function CaseClauseIsSelected(C, input) {
-    const clauseSelector = (0, _contextFree.GetValue)(Evaluate(C.test));
+  function* CaseClauseIsSelected(C, input) {
+    const clauseSelector = (0, _contextFree.GetValue)(yield* Evaluate(C.test));
     return input === clauseSelector;
   }
 
   // While statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-whileloopevaluation
-  function WhileLoopEvaluation(node) {
+  function* WhileLoopEvaluation(node) {
     let V;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-      const exprValue = (0, _contextFree.GetValue)(Evaluate(node.test));
+      const exprValue = (0, _contextFree.GetValue)(yield* Evaluate(node.test));
       if (!exprValue) {
         return (0, _ExecutionContext.NormalCompletion)(V);
       }
-      const stmtResult = Evaluate(node.body);
+      const stmtResult = yield* Evaluate(node.body);
       if (!(0, _contextFree.LoopContinues)(stmtResult)) {
         return (0, _contextFree.UpdateEmpty)(stmtResult, V);
       }
@@ -553,18 +604,18 @@ function cook(rootAst, codeSource, {
 
   // Do-while Statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-dowhileloopevaluation
-  function DoWhileLoopEvaluation(node) {
+  function* DoWhileLoopEvaluation(node) {
     let V;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-      const stmtResult = Evaluate(node.body);
+      const stmtResult = yield* Evaluate(node.body);
       if (!(0, _contextFree.LoopContinues)(stmtResult)) {
         return (0, _contextFree.UpdateEmpty)(stmtResult, V);
       }
       if (stmtResult.Value !== _ExecutionContext.Empty) {
         V = stmtResult.Value;
       }
-      const exprValue = (0, _contextFree.GetValue)(Evaluate(node.test));
+      const exprValue = (0, _contextFree.GetValue)(yield* Evaluate(node.test));
       if (!exprValue) {
         return (0, _ExecutionContext.NormalCompletion)(V);
       }
@@ -573,22 +624,22 @@ function cook(rootAst, codeSource, {
 
   // For in/of statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
-  function ForInOfLoopEvaluation(node) {
+  function* ForInOfLoopEvaluation(node) {
     const lhs = node.left;
     const isVariableDeclaration = lhs.type === "VariableDeclaration";
     const lhsKind = isVariableDeclaration ? lhs.kind === "var" ? "varBinding" : "lexicalBinding" : "assignment";
     const uninitializedBoundNames = lhsKind === "lexicalBinding" ? (0, _traverse.collectBoundNames)(lhs) : [];
     const iterationKind = node.type === "ForInStatement" ? "enumerate" : "iterate";
-    const keyResult = ForInOfHeadEvaluation(uninitializedBoundNames, node.right, iterationKind);
+    const keyResult = yield* 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);
+    return yield* ForInOfBodyEvaluation(lhs, node.body, keyResult.Value, iterationKind, lhsKind);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
-  function ForInOfHeadEvaluation(uninitializedBoundNames, expr, iterationKind) {
+  function* ForInOfHeadEvaluation(uninitializedBoundNames, expr, iterationKind) {
     const runningContext = getRunningContext();
     const oldEnv = runningContext.LexicalEnvironment;
     if (uninitializedBoundNames.length > 0) {
@@ -598,7 +649,7 @@ function cook(rootAst, codeSource, {
       }
       runningContext.LexicalEnvironment = newEnv;
     }
-    const exprRef = Evaluate(expr);
+    const exprRef = yield* Evaluate(expr, undefined, true);
     runningContext.LexicalEnvironment = oldEnv;
     const exprValue = (0, _contextFree.GetValue)(exprRef);
     if (iterationKind === "enumerate") {
@@ -611,7 +662,7 @@ function cook(rootAst, codeSource, {
     const iterator = (0, _contextFree.CreateListIteratorRecord)(exprValue);
     return (0, _ExecutionContext.NormalCompletion)(iterator);
   }
-  function ForInOfBodyEvaluation(node, stmt, iteratorRecord, iterationKind, lhsKind) {
+  function* ForInOfBodyEvaluation(node, stmt, iteratorRecord, iterationKind, lhsKind) {
     const lhs = lhsKind === "assignment" ? node : node.declarations[0].id;
     const oldEnv = getRunningContext().LexicalEnvironment;
     let V;
@@ -623,11 +674,13 @@ function cook(rootAst, codeSource, {
     const destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern";
     // eslint-disable-next-line no-constant-condition
     while (true) {
+      currentNode = lhs;
       const {
         done,
         value: nextValue
       } = iteratorRecord.next();
       if (done) {
+        if (debug) yield;
         return (0, _ExecutionContext.NormalCompletion)(V);
       }
       let lhsRef;
@@ -636,15 +689,19 @@ function cook(rootAst, codeSource, {
         iterationEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
         (0, _contextFree.ForDeclarationBindingInstantiation)(node, iterationEnv);
         getRunningContext().LexicalEnvironment = iterationEnv;
+        if (debug) yield;
         if (!destructuring) {
           const [lhsName] = (0, _traverse.collectBoundNames)(lhs);
           lhsRef = ResolveBinding(lhsName);
         }
-      } else if (!destructuring) {
-        lhsRef = Evaluate(lhs).Value;
+      } else {
+        if (debug) yield;
+        if (!destructuring) {
+          lhsRef = (yield* Evaluate(lhs)).Value;
+        }
       }
-      destructuring ? lhsKind === "assignment" ? DestructuringAssignmentEvaluation(lhs, nextValue) : lhsKind === "varBinding" ? BindingInitialization(lhs, nextValue, undefined) : BindingInitialization(lhs, nextValue, iterationEnv) : lhsKind === "lexicalBinding" ? (0, _contextFree.InitializeReferencedBinding)(lhsRef, nextValue) : (0, _contextFree.PutValue)(lhsRef, nextValue);
-      const result = Evaluate(stmt);
+      destructuring ? lhsKind === "assignment" ? yield* DestructuringAssignmentEvaluation(lhs, nextValue) : lhsKind === "varBinding" ? yield* BindingInitialization(lhs, nextValue, undefined) : yield* BindingInitialization(lhs, nextValue, iterationEnv) : lhsKind === "lexicalBinding" ? (0, _contextFree.InitializeReferencedBinding)(lhsRef, nextValue) : (0, _contextFree.PutValue)(lhsRef, nextValue);
+      const result = yield* Evaluate(stmt);
       getRunningContext().LexicalEnvironment = oldEnv;
       if (!(0, _contextFree.LoopContinues)(result)) {
         const status = (0, _contextFree.UpdateEmpty)(result, V);
@@ -673,13 +730,13 @@ function cook(rootAst, codeSource, {
 
   // For statements.
   // https://tc39.es/ecma262/#sec-runtime-semantics-forloopevaluation
-  function ForLoopEvaluation(node) {
+  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, []);
+        yield* Evaluate(node.init);
+        return yield* ForBodyEvaluation(node.test, node.update, node.body, []);
       }
       // `for (let/const … ; … ; … ) …`
       const oldEnv = getRunningContext().LexicalEnvironment;
@@ -694,34 +751,34 @@ function cook(rootAst, codeSource, {
         }
       }
       getRunningContext().LexicalEnvironment = loopEnv;
-      Evaluate(node.init);
+      yield* Evaluate(node.init);
       const perIterationLets = isConst ? [] : Array.from(boundNames);
-      const bodyResult = ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
+      const bodyResult = yield* ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
       getRunningContext().LexicalEnvironment = oldEnv;
       return bodyResult;
     }
     // `for ( … ; … ; … ) …`
     if (node.init) {
-      const exprRef = Evaluate(node.init);
+      const exprRef = yield* Evaluate(node.init);
       (0, _contextFree.GetValue)(exprRef);
     }
-    return ForBodyEvaluation(node.test, node.update, node.body, []);
+    return yield* ForBodyEvaluation(node.test, node.update, node.body, []);
   }
 
   // https://tc39.es/ecma262/#sec-forbodyevaluation
-  function ForBodyEvaluation(test, increment, stmt, perIterationBindings) {
+  function* ForBodyEvaluation(test, increment, stmt, perIterationBindings) {
     CreatePerIterationEnvironment(perIterationBindings);
     let V;
     // eslint-disable-next-line no-constant-condition
     while (true) {
       if (test) {
-        const testRef = Evaluate(test);
+        const testRef = yield* Evaluate(test, undefined, true);
         const testValue = (0, _contextFree.GetValue)(testRef);
         if (!testValue) {
           return (0, _ExecutionContext.NormalCompletion)(V);
         }
       }
-      const result = Evaluate(stmt);
+      const result = yield* Evaluate(stmt);
       if (!(0, _contextFree.LoopContinues)(result)) {
         return (0, _contextFree.UpdateEmpty)(result, V);
       }
@@ -730,7 +787,7 @@ function cook(rootAst, codeSource, {
       }
       CreatePerIterationEnvironment(perIterationBindings);
       if (increment) {
-        const incRef = Evaluate(increment);
+        const incRef = yield* Evaluate(increment, undefined, true);
         (0, _contextFree.GetValue)(incRef);
       }
     }
@@ -754,77 +811,80 @@ function cook(rootAst, codeSource, {
 
   // Destructuring assignments.
   // https://tc39.es/ecma262/#sec-runtime-semantics-destructuringassignmentevaluation
-  function DestructuringAssignmentEvaluation(pattern, value) {
+  function* DestructuringAssignmentEvaluation(pattern, value) {
     if (pattern.type === "ObjectPattern") {
       (0, _contextFree.RequireObjectCoercible)(value);
       if (pattern.properties.length > 0) {
-        PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
+        yield* PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
       }
       return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
     }
     const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(value);
-    return IteratorDestructuringAssignmentEvaluation(pattern.elements, iteratorRecord);
+    return yield* IteratorDestructuringAssignmentEvaluation(pattern.elements, iteratorRecord);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-propertydestructuringassignmentevaluation
-  function PropertyDestructuringAssignmentEvaluation(properties, value) {
+  function* PropertyDestructuringAssignmentEvaluation(properties, value) {
     const excludedNames = new Set();
     for (const prop of properties) {
       if (prop.type === "Property") {
-        const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : EvaluateComputedPropertyName(prop.key);
+        const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : yield* EvaluateComputedPropertyName(prop.key);
         const valueTarget = prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value;
         if (valueTarget.type === "Identifier") {
           const lref = ResolveBinding(valueTarget.name);
           let v = (0, _contextFree.GetV)(value, propName);
           if (prop.value.type === "AssignmentPattern" && v === undefined) {
-            // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-            const defaultValue = Evaluate(prop.value.right);
-            v = (0, _contextFree.GetValue)(defaultValue);
+            if (IsAnonymousFunctionDefinition(prop.value.right)) {
+              v = NamedEvaluation(prop.value.right, valueTarget.name);
+            } else {
+              const defaultValue = yield* Evaluate(prop.value.right);
+              v = (0, _contextFree.GetValue)(defaultValue);
+            }
           }
           (0, _contextFree.PutValue)(lref, v);
           excludedNames.add(propName);
         } else {
-          KeyedDestructuringAssignmentEvaluation(prop.value, value, propName);
+          yield* KeyedDestructuringAssignmentEvaluation(prop.value, value, propName);
           excludedNames.add(propName);
         }
       } else {
-        RestDestructuringAssignmentEvaluation(prop, value, excludedNames);
+        yield* RestDestructuringAssignmentEvaluation(prop, value, excludedNames);
       }
     }
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-keyeddestructuringassignmentevaluation
-  function KeyedDestructuringAssignmentEvaluation(node, value, propertyName) {
+  function* KeyedDestructuringAssignmentEvaluation(node, value, propertyName) {
     const assignmentTarget = node.type === "AssignmentPattern" ? node.left : node;
     const isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
     let lref;
     if (!isObjectOrArray) {
-      lref = Evaluate(assignmentTarget).Value;
+      lref = (yield* Evaluate(assignmentTarget)).Value;
     }
     const v = (0, _contextFree.GetV)(value, propertyName);
     let rhsValue;
     if (node.type === "AssignmentPattern" && v === undefined) {
-      // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-      const defaultValue = Evaluate(node.right);
+      // `assignmentTarget.type` is never "Identifier" here.
+      const defaultValue = yield* Evaluate(node.right);
       rhsValue = (0, _contextFree.GetValue)(defaultValue);
     } else {
       rhsValue = v;
     }
     if (isObjectOrArray) {
-      return DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
+      return yield* DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
     }
     return (0, _contextFree.PutValue)(lref, rhsValue);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
-  function RestDestructuringAssignmentEvaluation(restProperty, value, excludedNames) {
-    const lref = Evaluate(restProperty.argument).Value;
+  function* RestDestructuringAssignmentEvaluation(restProperty, value, excludedNames) {
+    const lref = (yield* Evaluate(restProperty.argument)).Value;
     const restObj = (0, _contextFree.CopyDataProperties)({}, value, excludedNames);
     return (0, _contextFree.PutValue)(lref, restObj);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
-  function IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
+  function* IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
     let status = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
     for (const element of elements) {
       if (!element) {
@@ -836,7 +896,7 @@ function cook(rootAst, codeSource, {
       const isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
       let lref;
       if (!isObjectOrArray) {
-        lref = Evaluate(assignmentTarget).Value;
+        lref = (yield* Evaluate(assignmentTarget)).Value;
       }
       let v;
       if (element.type !== "RestElement") {
@@ -846,15 +906,18 @@ function cook(rootAst, codeSource, {
         } = iteratorRecord.next();
         const value = done ? undefined : nextValue;
         if (element.type === "AssignmentPattern" && value === undefined) {
-          // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-          const defaultValue = Evaluate(element.right);
-          v = (0, _contextFree.GetValue)(defaultValue);
+          if (IsAnonymousFunctionDefinition(element.right) && assignmentTarget.type === "Identifier") {
+            v = NamedEvaluation(element.right, assignmentTarget.name);
+          } else {
+            const defaultValue = yield* Evaluate(element.right);
+            v = (0, _contextFree.GetValue)(defaultValue);
+          }
         } else {
           v = value;
         }
       } else {
         // RestElement
-        v = [];
+        v = new ArrayConstructor();
         let n = 0;
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -870,7 +933,7 @@ function cook(rootAst, codeSource, {
         }
       }
       if (isObjectOrArray) {
-        status = DestructuringAssignmentEvaluation(assignmentTarget, v);
+        status = yield* DestructuringAssignmentEvaluation(assignmentTarget, v);
       } else {
         status = (0, _contextFree.PutValue)(lref, v);
       }
@@ -880,8 +943,8 @@ function cook(rootAst, codeSource, {
 
   // Object expressions.
   // https://tc39.es/ecma262/#sec-evaluate-property-access-with-expression-key
-  function EvaluatePropertyAccessWithExpressionKey(baseValue, expression, strict) {
-    const propertyNameReference = Evaluate(expression);
+  function* EvaluatePropertyAccessWithExpressionKey(baseValue, expression, strict) {
+    const propertyNameReference = yield* Evaluate(expression);
     const propertyNameValue = (0, _contextFree.GetValue)(propertyNameReference);
     const propertyKey = (0, _contextFree.ToPropertyKey)(propertyNameValue);
     return new _ExecutionContext.ReferenceRecord(baseValue, propertyKey, strict);
@@ -919,33 +982,41 @@ function cook(rootAst, codeSource, {
 
   // Function declarations and expressions.
   // https://tc39.es/ecma262/#sec-evaluatecall
-  function EvaluateCall(func, ref, args, callee) {
+  function* EvaluateCall(func, ref, args, callee) {
     let thisValue;
     if (ref instanceof _ExecutionContext.ReferenceRecord) {
       if ((0, _contextFree.IsPropertyReference)(ref)) {
         thisValue = ref.Base;
       }
     }
-    const argList = ArgumentListEvaluation(args);
+    const argList = yield* ArgumentListEvaluation(args);
     if (typeof func !== "function") {
       const funcName = codeSource.substring(callee.start, callee.end);
       throw new TypeError(`${funcName} is not a function`);
     }
+    if (debug || externalSourceForDebug) {
+      const debuggerCall = func[_ExecutionContext.DebuggerCall];
+      if (debuggerCall) {
+        const result = yield* debuggerCall.apply(thisValue, argList);
+        doSanitize(result);
+        return (0, _ExecutionContext.NormalCompletion)(result);
+      }
+    }
     const result = func.apply(thisValue, argList);
-    (0, _sanitize.sanitize)(result);
+    doSanitize(result);
     return (0, _ExecutionContext.NormalCompletion)(result);
   }
 
   // https://tc39.es/ecma262/#sec-evaluatenew
-  function EvaluateNew(constructExpr, args) {
-    const ref = Evaluate(constructExpr);
+  function* EvaluateNew(constructExpr, args) {
+    const ref = yield* Evaluate(constructExpr);
     const constructor = (0, _contextFree.GetValue)(ref);
-    const argList = ArgumentListEvaluation(args);
+    const argList = yield* ArgumentListEvaluation(args);
     if (typeof constructor !== "function" || constructor[_ExecutionContext.IsConstructor] === false) {
       const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError(`${constructorName} is not a constructor`);
     }
-    if (!(0, _sanitize.isAllowedConstructor)(constructor)) {
+    if (!externalSourceForDebug && !(0, _sanitize.isAllowedConstructor)(constructor) && constructor !== ArrayConstructor) {
       const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError(`${constructorName} is not an allowed constructor`);
     }
@@ -953,32 +1024,43 @@ function cook(rootAst, codeSource, {
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
-  function ArgumentListEvaluation(args) {
+  function* ArgumentListEvaluation(args) {
     const array = [];
     if (Array.isArray(args)) {
       for (const arg of args) {
         if (arg.type === "SpreadElement") {
-          const spreadValues = (0, _contextFree.GetValue)(Evaluate(arg.argument));
+          const spreadValues = (0, _contextFree.GetValue)(yield* Evaluate(arg.argument));
           array.push(...spreadValues);
         } else {
-          array.push((0, _contextFree.GetValue)(Evaluate(arg)));
+          array.push((0, _contextFree.GetValue)(yield* Evaluate(arg)));
         }
       }
     } else {
       array.push(GetTemplateObject(args));
       for (const expr of args.expressions) {
-        array.push((0, _contextFree.GetValue)(Evaluate(expr)));
+        array.push((0, _contextFree.GetValue)(yield* Evaluate(expr)));
       }
     }
     return array;
   }
 
   // https://tc39.es/ecma262/#sec-ecmascript-function-objects-call-thisargument-argumentslist
-  function CallFunction(closure, args) {
+  function* CallFunction(closure, thisArgument, args) {
     var _hooks$beforeCall;
     (_hooks$beforeCall = hooks.beforeCall) === null || _hooks$beforeCall === void 0 || _hooks$beforeCall.call(hooks, closure[_ExecutionContext.SourceNode]);
-    PrepareForOrdinaryCall(closure);
-    const result = OrdinaryCallEvaluateBody(closure, args);
+    const calleeContext = PrepareForOrdinaryCall(closure);
+    OrdinaryCallBindThis(closure, calleeContext, thisArgument);
+    const result = yield* OrdinaryCallEvaluateBody(closure, args);
+    if (debug) {
+      currentNode = {
+        ...closure[_ExecutionContext.SourceNode],
+        [_ExecutionContext.DebuggerReturn]: true
+      };
+      yield {
+        type: "return",
+        value: result.Type === "return" ? result.Value : undefined
+      };
+    }
     executionContextStack.pop();
     if (result.Type === "return") {
       return result.Value;
@@ -990,32 +1072,39 @@ function cook(rootAst, codeSource, {
   function PrepareForOrdinaryCall(F) {
     const calleeContext = new _ExecutionContext.ExecutionContext();
     calleeContext.Function = F;
-    const localEnv = new _ExecutionContext.FunctionEnvironment(F[_ExecutionContext.Environment]);
+    const localEnv = new _ExecutionContext.FunctionEnvironment(F);
     calleeContext.VariableEnvironment = localEnv;
     calleeContext.LexicalEnvironment = localEnv;
     executionContextStack.push(calleeContext);
     return calleeContext;
   }
+  function OrdinaryCallBindThis(F, calleeContext, thisArgument) {
+    if (F[_ExecutionContext.ThisMode] === _ExecutionContext.Mode.LEXICAL) {
+      return;
+    }
+    const localEnv = calleeContext.LexicalEnvironment;
+    localEnv === null || localEnv === void 0 || localEnv.BindThisValue(thisArgument);
+  }
 
   // https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
-  function OrdinaryCallEvaluateBody(F, args) {
-    return EvaluateFunctionBody(F[_ExecutionContext.ECMAScriptCode], F, args);
+  function* OrdinaryCallEvaluateBody(F, args) {
+    return yield* EvaluateFunctionBody(F[_ExecutionContext.ECMAScriptCode], F, args);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody
-  function EvaluateFunctionBody(body, F, args) {
-    FunctionDeclarationInstantiation(F, args);
+  function* EvaluateFunctionBody(body, F, args) {
+    yield* FunctionDeclarationInstantiation(F, args);
     if (Array.isArray(body)) {
-      return EvaluateStatementList(body);
+      return yield* EvaluateStatementList(body);
     }
-    return new _ExecutionContext.CompletionRecord("return", (0, _contextFree.GetValue)(Evaluate(body)));
+    return new _ExecutionContext.CompletionRecord("return", (0, _contextFree.GetValue)(yield* Evaluate(body)));
   }
 
   // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
-  function EvaluateStatementList(statements) {
+  function* EvaluateStatementList(statements) {
     let result = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
     for (const stmt of statements) {
-      const s = Evaluate(stmt);
+      const s = yield* Evaluate(stmt);
       if (s.Type !== "normal") {
         return s;
       }
@@ -1023,9 +1112,39 @@ function cook(rootAst, codeSource, {
     }
     return result;
   }
+  function GetThisEnvironment() {
+    let env = getRunningContext().LexicalEnvironment;
+    while (env) {
+      if (env.HasThisBinding()) {
+        return env;
+      }
+      env = env.OuterEnv;
+    }
+    throw new Error("Accessing global this is forbidden");
+  }
+
+  // https://tc39.es/ecma262/#sec-isanonymousfunctiondefinition
+  function IsAnonymousFunctionDefinition(node) {
+    // No ParenthesizedExpression in ESTree.
+    return node.type === "FunctionExpression" && !node.id || node.type === "ArrowFunctionExpression";
+  }
+
+  // https://tc39.es/ecma262/#sec-runtime-semantics-namedevaluation
+  function NamedEvaluation(node, name) {
+    // No ParenthesizedExpression in ESTree.
+    switch (node.type) {
+      case "FunctionExpression":
+        return InstantiateOrdinaryFunctionExpression(node, name);
+      case "ArrowFunctionExpression":
+        return InstantiateArrowFunctionExpression(node, name);
+      // istanbul ignore next: should never happen
+      default:
+        throw new Error(`Unexpected node type for NamedEvaluation: ${node.type}`);
+    }
+  }
 
   // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
-  function FunctionDeclarationInstantiation(func, args) {
+  function* FunctionDeclarationInstantiation(func, args) {
     const calleeContext = getRunningContext();
     const code = func[_ExecutionContext.ECMAScriptCode];
     const formals = func[_ExecutionContext.FormalParameters];
@@ -1054,20 +1173,44 @@ function cook(rootAst, codeSource, {
         throw new SyntaxError("Var declaration is not recommended, use `let` or `const` instead");
       }
     }
+
+    // let argumentsObjectNeeded = true;
+    // if (func[ThisMode] === Mode.LEXICAL) {
+    //   // NOTE: Arrow functions never have an arguments object.
+    //   argumentsObjectNeeded = false;
+    // } else if (parameterNames.includes("arguments")) {
+    //   argumentsObjectNeeded = false;
+    // } else if (!hasParameterExpressions && (
+    //   varNames.includes("arguments") ||
+    //   collectBoundNames(collectScopedDeclarations(code, { var: false })).includes("arguments")
+    // )) {
+    //   argumentsObjectNeeded = false;
+    // }
+    // NOTE: In strict mode, no parameter/function/var/lexical names can be "arguments".
+    const argumentsObjectNeeded = !!externalSourceForDebug && func[_ExecutionContext.ThisMode] !== _ExecutionContext.Mode.LEXICAL;
     const env = calleeContext.LexicalEnvironment;
     for (const paramName of parameterNames) {
       // In strict mode, it's guaranteed no duplicate params exist.
       env.CreateMutableBinding(paramName, false);
     }
+    let parameterBindings = parameterNames;
+    if (argumentsObjectNeeded) {
+      const ao = CreateUnmappedArgumentsObject(args);
+      env.CreateImmutableBinding("arguments", false);
+      env.InitializeBinding("arguments", ao);
+      parameterBindings = parameterNames.concat("arguments");
+    }
     const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(args);
-    IteratorBindingInitialization(formals, iteratorRecord, env);
+    yield* IteratorBindingInitialization(formals, iteratorRecord, env);
     let varEnv;
     if (!hasParameterExpressions) {
       // NOTE: Only a single Environment Record is needed for the parameters
       // and top-level vars.
       // `varNames` are unique.
+      const instantiatedVarNames = [...parameterBindings];
       for (const n of varNames) {
-        if (!parameterNames.includes(n)) {
+        if (!instantiatedVarNames.includes(n)) {
+          instantiatedVarNames.push(n);
           env.CreateMutableBinding(n, false);
           env.InitializeBinding(n, undefined);
         }
@@ -1080,15 +1223,19 @@ function cook(rootAst, codeSource, {
       varEnv = new _ExecutionContext.DeclarativeEnvironment(env);
       calleeContext.VariableEnvironment = varEnv;
       // `varNames` are unique.
+      const instantiatedVarNames = [];
       for (const n of varNames) {
-        varEnv.CreateMutableBinding(n, false);
-        let initialValue;
-        if (parameterNames.includes(n) && !functionNames.includes(n)) {
-          initialValue = env.GetBindingValue(n, false);
+        if (!instantiatedVarNames.includes(n)) {
+          instantiatedVarNames.push(n);
+          varEnv.CreateMutableBinding(n, false);
+          let initialValue;
+          if (parameterBindings.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
+          // the same value as the corresponding initialized parameter.
         }
-        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.
       }
     }
     const lexEnv = varEnv;
@@ -1113,40 +1260,78 @@ function cook(rootAst, codeSource, {
       varEnv.SetMutableBinding(fn, fo, false);
     }
   }
+  function CreateUnmappedArgumentsObject(args) {
+    const argList = [...args];
+    const argumentObject = {};
+    Object.defineProperty(argumentObject, "length", {
+      value: argList.length,
+      writable: true,
+      configurable: true
+    });
+    for (let index = 0; index < argList.length; index++) {
+      argumentObject[String(index)] = argList[index];
+    }
+    Object.defineProperty(argumentObject, Symbol.iterator, {
+      value: Array.prototype.values,
+      writable: true,
+      configurable: true
+    });
+    const ThrowTypeError = () => {
+      throw new TypeError("'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them");
+    };
+    Object.defineProperty(argumentObject, "callee", {
+      get: ThrowTypeError,
+      set: ThrowTypeError
+    });
+    return argumentObject;
+  }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatefunctionobject
   function InstantiateFunctionObject(func, scope) {
-    return OrdinaryFunctionCreate(func, scope, true);
+    const F = OrdinaryFunctionCreate(func, scope, true, false);
+    if (func.id) {
+      SetFunctionName(F, func.id.name);
+    }
+    return F;
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
-  function InstantiateOrdinaryFunctionExpression(functionExpression) {
+  function InstantiateOrdinaryFunctionExpression(functionExpression, name) {
     const scope = getRunningContext().LexicalEnvironment;
     if (functionExpression.id) {
       const name = functionExpression.id.name;
       const funcEnv = new _ExecutionContext.DeclarativeEnvironment(scope);
       funcEnv.CreateImmutableBinding(name, false);
-      const closure = OrdinaryFunctionCreate(functionExpression, funcEnv, true);
+      const closure = OrdinaryFunctionCreate(functionExpression, funcEnv, true, false);
+      SetFunctionName(closure, name);
       funcEnv.InitializeBinding(name, closure);
       return closure;
     } else {
-      const closure = OrdinaryFunctionCreate(functionExpression, scope, true);
+      const closure = OrdinaryFunctionCreate(functionExpression, scope, true, false);
+      SetFunctionName(closure, name ?? "");
       return closure;
     }
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression
-  function InstantiateArrowFunctionExpression(arrowFunction) {
+  function InstantiateArrowFunctionExpression(arrowFunction, name) {
     const scope = getRunningContext().LexicalEnvironment;
-    const closure = OrdinaryFunctionCreate(arrowFunction, scope, false);
+    const closure = OrdinaryFunctionCreate(arrowFunction, scope, false, true);
+    SetFunctionName(closure, name ?? "");
     return closure;
   }
+  function SetFunctionName(F, name) {
+    Object.defineProperty(F, "name", {
+      value: name,
+      configurable: true
+    });
+  }
 
   // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
-  function OrdinaryFunctionCreate(sourceNode, scope, isConstructor) {
+  function OrdinaryFunctionCreate(sourceNode, scope, isConstructor, lexicalThis) {
     const F = function () {
       // eslint-disable-next-line prefer-rest-params
-      return CallFunction(F, arguments);
+      return unwind(CallFunction(F, this, arguments));
     };
     Object.defineProperties(F, {
       [_ExecutionContext.SourceNode]: {
@@ -1163,41 +1348,52 @@ function cook(rootAst, codeSource, {
       },
       [_ExecutionContext.IsConstructor]: {
         value: isConstructor
+      },
+      [_ExecutionContext.ThisMode]: {
+        value: lexicalThis ? _ExecutionContext.Mode.LEXICAL : _ExecutionContext.Mode.STRICT
       }
     });
+    if (debug || externalSourceForDebug) {
+      Object.defineProperty(F, _ExecutionContext.DebuggerCall, {
+        value: function () {
+          // eslint-disable-next-line prefer-rest-params
+          return CallFunction(F, this, arguments);
+        }
+      });
+    }
     return F;
   }
 
   // Patterns initialization.
   // https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
-  function BindingInitialization(node, value, environment) {
+  function* BindingInitialization(node, value, environment) {
     switch (node.type) {
       case "Identifier":
         return InitializeBoundName(node.name, value, environment);
       case "ObjectPattern":
         (0, _contextFree.RequireObjectCoercible)(value);
-        return PropertyBindingInitialization(node.properties, value, environment);
+        return yield* PropertyBindingInitialization(node.properties, value, environment);
       case "ArrayPattern":
         {
           const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(value);
-          return IteratorBindingInitialization(node.elements, iteratorRecord, environment);
+          return yield* IteratorBindingInitialization(node.elements, iteratorRecord, environment);
         }
     }
   }
 
   // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-propertybindinginitialization
-  function PropertyBindingInitialization(properties, value, environment) {
+  function* PropertyBindingInitialization(properties, value, environment) {
     const excludedNames = new Set();
     for (const prop of properties) {
       if (prop.type === "RestElement") {
         return RestBindingInitialization(prop, value, environment, excludedNames);
       }
       if (!prop.computed && prop.key.type === "Identifier") {
-        KeyedBindingInitialization(prop.value, value, environment, prop.key.name);
+        yield* KeyedBindingInitialization(prop.value, value, environment, prop.key.name);
         excludedNames.add(prop.key.name);
       } else {
-        const P = EvaluateComputedPropertyName(prop.key);
-        KeyedBindingInitialization(prop.value, value, environment, P);
+        const P = yield* EvaluateComputedPropertyName(prop.key);
+        yield* KeyedBindingInitialization(prop.value, value, environment, P);
         excludedNames.add(P);
       }
     }
@@ -1205,8 +1401,8 @@ function cook(rootAst, codeSource, {
   }
 
   // https://tc39.es/ecma262/#prod-ComputedPropertyName
-  function EvaluateComputedPropertyName(node) {
-    const propName = (0, _contextFree.GetValue)(Evaluate(node));
+  function* EvaluateComputedPropertyName(node) {
+    const propName = (0, _contextFree.GetValue)(yield* Evaluate(node));
     return (0, _contextFree.ToPropertyKey)(propName);
   }
 
@@ -1221,7 +1417,7 @@ function cook(rootAst, codeSource, {
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-iteratorbindinginitialization
-  function IteratorBindingInitialization(elements, iteratorRecord, environment) {
+  function* IteratorBindingInitialization(elements, iteratorRecord, environment) {
     if (elements.length === 0) {
       return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
     }
@@ -1235,7 +1431,7 @@ function cook(rootAst, codeSource, {
         // Rest element.
         if (node.argument.type === "Identifier") {
           const lhs = ResolveBinding(node.argument.name, environment);
-          const A = [];
+          const A = new ArrayConstructor();
           let n = 0;
           // eslint-disable-next-line no-constant-condition
           while (true) {
@@ -1251,7 +1447,7 @@ function cook(rootAst, codeSource, {
             n++;
           }
         } else {
-          const A = [];
+          const A = new ArrayConstructor();
           let n = 0;
           // eslint-disable-next-line no-constant-condition
           while (true) {
@@ -1260,7 +1456,7 @@ function cook(rootAst, codeSource, {
               value
             } = iteratorRecord.next();
             if (done) {
-              result = BindingInitialization(node.argument, A, environment);
+              result = yield* BindingInitialization(node.argument, A, environment);
               break;
             }
             A[n] = value;
@@ -1283,10 +1479,10 @@ function cook(rootAst, codeSource, {
                 v = value;
               }
               if (node.type === "AssignmentPattern" && v === undefined) {
-                const defaultValue = Evaluate(node.right);
+                const defaultValue = yield* Evaluate(node.right);
                 v = (0, _contextFree.GetValue)(defaultValue);
               }
-              result = BindingInitialization(bindingElement, v, environment);
+              result = yield* BindingInitialization(bindingElement, v, environment);
               break;
             }
           case "Identifier":
@@ -1302,9 +1498,12 @@ function cook(rootAst, codeSource, {
                 v = value;
               }
               if (node.type === "AssignmentPattern" && v === undefined) {
-                // IsAnonymousFunctionDefinition(Initializer)
-                const defaultValue = Evaluate(node.right);
-                v = (0, _contextFree.GetValue)(defaultValue);
+                if (IsAnonymousFunctionDefinition(node.right)) {
+                  v = NamedEvaluation(node.right, bindingId);
+                } else {
+                  const defaultValue = yield* Evaluate(node.right);
+                  v = (0, _contextFree.GetValue)(defaultValue);
+                }
               }
               result = environment ? (0, _contextFree.InitializeReferencedBinding)(lhs, v) : (0, _contextFree.PutValue)(lhs, v);
               break;
@@ -1316,16 +1515,19 @@ function cook(rootAst, codeSource, {
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-keyedbindinginitialization
-  function KeyedBindingInitialization(node, value, environment, propertyName) {
+  function* KeyedBindingInitialization(node, value, environment, propertyName) {
     const isIdentifier = node.type === "Identifier" || node.type === "AssignmentPattern" && node.left.type === "Identifier";
     if (isIdentifier) {
       const bindingId = node.type === "Identifier" ? node.name : node.left.name;
       const lhs = ResolveBinding(bindingId, environment);
       let v = (0, _contextFree.GetV)(value, propertyName);
       if (node.type === "AssignmentPattern" && v === undefined) {
-        // If IsAnonymousFunctionDefinition(Initializer)
-        const defaultValue = Evaluate(node.right);
-        v = (0, _contextFree.GetValue)(defaultValue);
+        if (IsAnonymousFunctionDefinition(node.right)) {
+          v = NamedEvaluation(node.right, bindingId);
+        } else {
+          const defaultValue = yield* Evaluate(node.right);
+          v = (0, _contextFree.GetValue)(defaultValue);
+        }
       }
       if (!environment) {
         return (0, _contextFree.PutValue)(lhs, v);
@@ -1334,10 +1536,10 @@ function cook(rootAst, codeSource, {
     }
     let v = (0, _contextFree.GetV)(value, propertyName);
     if (node.type === "AssignmentPattern" && v === undefined) {
-      const defaultValue = Evaluate(node.right);
+      const defaultValue = yield* Evaluate(node.right);
       v = (0, _contextFree.GetValue)(defaultValue);
     }
-    return BindingInitialization(node.type === "AssignmentPattern" ? node.left : node, v, environment);
+    return yield* BindingInitialization(node.type === "AssignmentPattern" ? node.left : node, v, environment);
   }
 
   // https://tc39.es/ecma262/#sec-initializeboundname
@@ -1355,7 +1557,7 @@ function cook(rootAst, codeSource, {
     }
   }
   if (expressionOnly) {
-    return (0, _contextFree.GetValue)(Evaluate(rootAst));
+    return (0, _contextFree.GetValue)(unwind(Evaluate(rootAst)));
   }
   (_hooks$beforeEvaluate3 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate3 === void 0 || _hooks$beforeEvaluate3.call(hooks, rootAst);
   ThrowIfFunctionIsInvalid(rootAst);
@@ -1364,6 +1566,32 @@ function cook(rootAst, codeSource, {
   rootEnv.CreateImmutableBinding(fn, true);
   const fo = InstantiateFunctionObject(rootAst, rootEnv);
   rootEnv.InitializeBinding(fn, fo);
+  if (debug) {
+    Object.defineProperties(fo, {
+      [_ExecutionContext.DebuggerScope]: {
+        value: function () {
+          return getRunningContext().LexicalEnvironment;
+        }
+      },
+      [_ExecutionContext.DebuggerNode]: {
+        value: function () {
+          return currentNode;
+        }
+      }
+    });
+  }
   return fo;
 }
+function unwind(iterator) {
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const {
+      done,
+      value
+    } = iterator.next();
+    if (done) {
+      return value;
+    }
+  }
+}
 //# sourceMappingURL=cook.js.map