@next-core/cook 2.2.18 → 2.4.0

package/dist/esm/cook.js

@@ -1,5 +1,5 @@
 import { ApplyStringOrNumericAssignment, CreateListIteratorRecord, ApplyStringOrNumericBinaryOperator, GetV, GetValue, InitializeReferencedBinding, IsPropertyReference, LoopContinues, PutValue, RequireObjectCoercible, ToPropertyKey, UpdateEmpty, ApplyUnaryOperator, GetIdentifierReference, ForDeclarationBindingInstantiation, CopyDataProperties } from "./context-free.js";
-import { CompletionRecord, DeclarativeEnvironment, ECMAScriptCode, Empty, Environment, ExecutionContext, FormalParameters, FunctionEnvironment, IsConstructor, NormalCompletion, ReferenceRecord, SourceNode } from "./ExecutionContext.js";
+import { CompletionRecord, DebuggerCall, DebuggerNode, DebuggerReturn, DebuggerScope, DeclarativeEnvironment, ECMAScriptCode, Empty, Environment, ExecutionContext, FormalParameters, FunctionEnvironment, IsConstructor, NormalCompletion, ReferenceRecord, SourceNode, Mode, ThisMode } from "./ExecutionContext.js";
 import { sanitize, isAllowedConstructor } from "./sanitize.js";
 import { collectBoundNames, collectScopedDeclarations, containsExpression } from "./traverse.js";
 /** For next-core internal usage only. */
@@ -7,10 +7,19 @@ export function cook(rootAst, codeSource) {
   var _hooks$beforeEvaluate3;
   let {
     rules,
+    debug,
+    externalSourceForDebug,
     globalVariables = {},
+    // Allow debugger to override Array constructor.
+    ArrayConstructor = Array,
     hooks = {}
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const expressionOnly = rootAst.type !== "FunctionDeclaration";
+  function doSanitize(cooked) {
+    if (!externalSourceForDebug) {
+      sanitize(cooked);
+    }
+  }
   const rootEnv = new DeclarativeEnvironment(null);
   const rootContext = new ExecutionContext();
   rootContext.VariableEnvironment = rootEnv;
@@ -41,23 +50,28 @@ export 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 = GetValue(Evaluate(element.argument));
+              const spreadValues = GetValue(yield* Evaluate(element.argument));
               array.push(...spreadValues);
             } else {
-              array.push(GetValue(Evaluate(element)));
+              array.push(GetValue(yield* Evaluate(element)));
             }
           }
           return NormalCompletion(array);
@@ -71,9 +85,9 @@ export function cook(rootAst, codeSource) {
         }
       case "BinaryExpression":
         {
-          const leftRef = Evaluate(node.left);
+          const leftRef = yield* Evaluate(node.left);
           const leftValue = GetValue(leftRef);
-          const rightRef = Evaluate(node.right).Value;
+          const rightRef = yield* Evaluate(node.right);
           const rightValue = GetValue(rightRef);
           if (expressionOnly && node.operator === "|>") {
             // Minimal pipeline operator is supported only in expression-only mode.
@@ -98,21 +112,22 @@ export 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 = GetValue(ref);
           if ((func === undefined || func === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return NormalCompletion(undefined);
           }
-          sanitize(func);
-          return EvaluateCall(func, ref, node.arguments, node.callee);
+          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 NormalCompletion(GetValue(Evaluate(GetValue(Evaluate(node.test)) ? node.consequent : node.alternate)));
+        return NormalCompletion(GetValue(yield* Evaluate(GetValue(yield* Evaluate(node.test)) ? node.consequent : node.alternate)));
       case "Identifier":
         // https://tc39.es/ecma262/#sec-identifiers
         return NormalCompletion(ResolveBinding(node.name));
@@ -134,14 +149,14 @@ export function cook(rootAst, codeSource) {
       case "LogicalExpression":
         {
           // https://tc39.es/ecma262/#sec-binary-logical-operators
-          const leftValue = GetValue(Evaluate(node.left));
+          const leftValue = GetValue(yield* Evaluate(node.left));
           switch (node.operator) {
             case "&&":
-              return NormalCompletion(leftValue && GetValue(Evaluate(node.right)));
+              return NormalCompletion(leftValue && GetValue(yield* Evaluate(node.right)));
             case "||":
-              return NormalCompletion(leftValue || GetValue(Evaluate(node.right)));
+              return NormalCompletion(leftValue || GetValue(yield* Evaluate(node.right)));
             case "??":
-              return NormalCompletion(leftValue ?? GetValue(Evaluate(node.right)));
+              return NormalCompletion(leftValue ?? GetValue(yield* Evaluate(node.right)));
             // istanbul ignore next
             default:
               throw new SyntaxError(
@@ -153,37 +168,41 @@ export 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 = GetValue(baseReference);
           if ((baseValue === undefined || baseValue === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
             optionalChainRef.skipped = true;
             return NormalCompletion(undefined);
           }
-          sanitize(baseValue);
-          const result = node.computed ? EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
-          sanitize(result);
+          doSanitize(baseValue);
+          const result = node.computed ? yield* EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
+          doSanitize(result);
           return 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 = GetValue(Evaluate(prop.argument));
+              const fromValue = GetValue(yield* Evaluate(prop.argument));
               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] = GetValue(Evaluate(prop.value));
+              const propValue = GetValue(yield* Evaluate(prop.value));
+              if (prop.method && typeof propValue === "function") {
+                SetFunctionName(propValue, propName);
+              }
+              object[propName] = propValue;
             }
           }
           return NormalCompletion(object);
@@ -193,7 +212,7 @@ export function cook(rootAst, codeSource) {
           // https://tc39.es/ecma262/#sec-comma-operator
           let result;
           for (const expr of node.expressions) {
-            result = NormalCompletion(GetValue(Evaluate(expr)));
+            result = NormalCompletion(GetValue(yield* Evaluate(expr)));
           }
           return result;
         }
@@ -203,7 +222,7 @@ export function cook(rootAst, codeSource) {
           const chunks = [node.quasis[0].value.cooked];
           let index = 0;
           for (const expr of node.expressions) {
-            const val = GetValue(Evaluate(expr));
+            const val = GetValue(yield* Evaluate(expr));
             chunks.push(String(val));
             chunks.push(node.quasis[index += 1].value.cooked);
           }
@@ -212,15 +231,16 @@ export 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 = GetValue(tagRef);
-          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 ReferenceRecord)) {
@@ -250,22 +270,26 @@ export 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 = 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 = GetValue(rref);
+                }
                 PutValue(lref, rval);
                 return NormalCompletion(rval);
               }
-              const rref = Evaluate(node.right);
+              const rref = yield* Evaluate(node.right);
               const rval = GetValue(rref);
-              DestructuringAssignmentEvaluation(node.left, rval);
+              yield* DestructuringAssignmentEvaluation(node.left, rval);
               return NormalCompletion(rval);
             }
             // Operators other than `=`.
-            const lref = Evaluate(node.left).Value;
+            const lref = (yield* Evaluate(node.left)).Value;
             const lval = GetValue(lref);
-            const rref = Evaluate(node.right);
+            const rref = yield* Evaluate(node.right);
             const rval = GetValue(rref);
             const r = ApplyStringOrNumericAssignment(lval, node.operator, rval);
             PutValue(lref, r);
@@ -281,7 +305,7 @@ export function cook(rootAst, codeSource) {
             const blockEnv = new 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;
           }
@@ -296,18 +320,18 @@ export function cook(rootAst, codeSource) {
           return NormalCompletion(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 NormalCompletion(Empty);
@@ -317,41 +341,58 @@ export function cook(rootAst, codeSource) {
           return NormalCompletion(InstantiateOrdinaryFunctionExpression(node));
         case "IfStatement":
           // https://tc39.es/ecma262/#sec-if-statement
-          return GetValue(Evaluate(node.test)) ? ((_hooks$beforeBranch = hooks.beforeBranch) !== null && _hooks$beforeBranch !== void 0 && _hooks$beforeBranch.call(hooks, node, "if"), UpdateEmpty(Evaluate(node.consequent), undefined)) : ((_hooks$beforeBranch2 = hooks.beforeBranch) !== null && _hooks$beforeBranch2 !== void 0 && _hooks$beforeBranch2.call(hooks, node, "else"), node.alternate) ? UpdateEmpty(Evaluate(node.alternate), undefined) : NormalCompletion(undefined);
+          if (GetValue(yield* Evaluate(node.test))) {
+            var _hooks$beforeBranch;
+            (_hooks$beforeBranch = hooks.beforeBranch) === null || _hooks$beforeBranch === void 0 || _hooks$beforeBranch.call(hooks, node, "if");
+            return 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 UpdateEmpty(yield* Evaluate(node.alternate), undefined);
+          }
+          return 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 = GetValue(exprRef);
             }
             return new CompletionRecord("return", v);
           }
+        case "ThisExpression":
+          {
+            if (!externalSourceForDebug) {
+              break;
+            }
+            const envRec = GetThisEnvironment();
+            return NormalCompletion(envRec.GetThisBinding());
+          }
         case "ThrowStatement":
           // https://tc39.es/ecma262/#sec-throw-statement
-          throw GetValue(Evaluate(node.argument));
+          throw 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(GetValue(lhs));
             const newValue = node.operator === "++" ? oldValue + 1 : oldValue - 1;
             PutValue(lhs, newValue);
             return 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 = GetValue(exprRef);
             const oldEnv = getRunningContext().LexicalEnvironment;
             const blockEnv = new 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);
           }
@@ -360,18 +401,19 @@ export 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;
                 }
@@ -384,6 +426,7 @@ export 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") {
@@ -393,23 +436,31 @@ export function cook(rootAst, codeSource) {
                   result = 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 = GetValue(rhs);
+                let value;
+                if (IsAnonymousFunctionDefinition(declarator.init)) {
+                  value = NamedEvaluation(declarator.init, bindingId);
+                } else {
+                  const rhs = yield* Evaluate(declarator.init);
+                  value = GetValue(rhs);
+                }
                 result = node.kind === "var" ? PutValue(lhs, value) : InitializeReferencedBinding(lhs, value);
               } else {
-                const rhs = Evaluate(declarator.init);
+                currentNode = declarator.init;
+                if (debug) yield;
+                const rhs = yield* Evaluate(declarator.init);
                 const rval = 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
@@ -431,9 +482,9 @@ export 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 DeclarativeEnvironment(oldEnv);
@@ -441,8 +492,8 @@ export 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;
   }
@@ -455,7 +506,7 @@ export 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;
@@ -463,10 +514,10 @@ export 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 !== Empty) {
           V = R.Value;
         }
@@ -483,10 +534,10 @@ export 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 !== Empty) {
             V = R.Value;
           }
@@ -499,7 +550,7 @@ export function cook(rootAst, codeSource) {
     if (foundInB) {
       return NormalCompletion(V);
     }
-    const R = Evaluate(cases[defaultCaseIndex]);
+    const R = yield* Evaluate(cases[defaultCaseIndex]);
     if (R.Value !== Empty) {
       V = R.Value;
     }
@@ -509,7 +560,7 @@ export 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 !== Empty) {
         V = R.Value;
       }
@@ -521,22 +572,22 @@ export function cook(rootAst, codeSource) {
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
-  function CaseClauseIsSelected(C, input) {
-    const clauseSelector = GetValue(Evaluate(C.test));
+  function* CaseClauseIsSelected(C, input) {
+    const clauseSelector = 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 = GetValue(Evaluate(node.test));
+      const exprValue = GetValue(yield* Evaluate(node.test));
       if (!exprValue) {
         return NormalCompletion(V);
       }
-      const stmtResult = Evaluate(node.body);
+      const stmtResult = yield* Evaluate(node.body);
       if (!LoopContinues(stmtResult)) {
         return UpdateEmpty(stmtResult, V);
       }
@@ -548,18 +599,18 @@ export 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 (!LoopContinues(stmtResult)) {
         return UpdateEmpty(stmtResult, V);
       }
       if (stmtResult.Value !== Empty) {
         V = stmtResult.Value;
       }
-      const exprValue = GetValue(Evaluate(node.test));
+      const exprValue = GetValue(yield* Evaluate(node.test));
       if (!exprValue) {
         return NormalCompletion(V);
       }
@@ -568,22 +619,22 @@ export 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" ? 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) {
@@ -593,7 +644,7 @@ export function cook(rootAst, codeSource) {
       }
       runningContext.LexicalEnvironment = newEnv;
     }
-    const exprRef = Evaluate(expr);
+    const exprRef = yield* Evaluate(expr, undefined, true);
     runningContext.LexicalEnvironment = oldEnv;
     const exprValue = GetValue(exprRef);
     if (iterationKind === "enumerate") {
@@ -606,7 +657,7 @@ export function cook(rootAst, codeSource) {
     const iterator = CreateListIteratorRecord(exprValue);
     return 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;
@@ -618,11 +669,13 @@ export 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 NormalCompletion(V);
       }
       let lhsRef;
@@ -631,15 +684,19 @@ export function cook(rootAst, codeSource) {
         iterationEnv = new DeclarativeEnvironment(oldEnv);
         ForDeclarationBindingInstantiation(node, iterationEnv);
         getRunningContext().LexicalEnvironment = iterationEnv;
+        if (debug) yield;
         if (!destructuring) {
           const [lhsName] = 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" ? InitializeReferencedBinding(lhsRef, nextValue) : 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" ? InitializeReferencedBinding(lhsRef, nextValue) : PutValue(lhsRef, nextValue);
+      const result = yield* Evaluate(stmt);
       getRunningContext().LexicalEnvironment = oldEnv;
       if (!LoopContinues(result)) {
         const status = UpdateEmpty(result, V);
@@ -668,13 +725,13 @@ export 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;
@@ -689,34 +746,34 @@ export 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);
       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 = GetValue(testRef);
         if (!testValue) {
           return NormalCompletion(V);
         }
       }
-      const result = Evaluate(stmt);
+      const result = yield* Evaluate(stmt);
       if (!LoopContinues(result)) {
         return UpdateEmpty(result, V);
       }
@@ -725,7 +782,7 @@ export function cook(rootAst, codeSource) {
       }
       CreatePerIterationEnvironment(perIterationBindings);
       if (increment) {
-        const incRef = Evaluate(increment);
+        const incRef = yield* Evaluate(increment, undefined, true);
         GetValue(incRef);
       }
     }
@@ -749,77 +806,80 @@ export 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") {
       RequireObjectCoercible(value);
       if (pattern.properties.length > 0) {
-        PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
+        yield* PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
       }
       return NormalCompletion(Empty);
     }
     const iteratorRecord = 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 = GetV(value, propName);
           if (prop.value.type === "AssignmentPattern" && v === undefined) {
-            // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
-            const defaultValue = Evaluate(prop.value.right);
-            v = GetValue(defaultValue);
+            if (IsAnonymousFunctionDefinition(prop.value.right)) {
+              v = NamedEvaluation(prop.value.right, valueTarget.name);
+            } else {
+              const defaultValue = yield* Evaluate(prop.value.right);
+              v = GetValue(defaultValue);
+            }
           }
           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 = 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 = GetValue(defaultValue);
     } else {
       rhsValue = v;
     }
     if (isObjectOrArray) {
-      return DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
+      return yield* DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
     }
     return 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 = CopyDataProperties({}, value, excludedNames);
     return PutValue(lref, restObj);
   }
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
-  function IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
+  function* IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
     let status = NormalCompletion(Empty);
     for (const element of elements) {
       if (!element) {
@@ -831,7 +891,7 @@ export 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") {
@@ -841,15 +901,18 @@ export 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 = GetValue(defaultValue);
+          if (IsAnonymousFunctionDefinition(element.right) && assignmentTarget.type === "Identifier") {
+            v = NamedEvaluation(element.right, assignmentTarget.name);
+          } else {
+            const defaultValue = yield* Evaluate(element.right);
+            v = GetValue(defaultValue);
+          }
         } else {
           v = value;
         }
       } else {
         // RestElement
-        v = [];
+        v = new ArrayConstructor();
         let n = 0;
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -865,7 +928,7 @@ export function cook(rootAst, codeSource) {
         }
       }
       if (isObjectOrArray) {
-        status = DestructuringAssignmentEvaluation(assignmentTarget, v);
+        status = yield* DestructuringAssignmentEvaluation(assignmentTarget, v);
       } else {
         status = PutValue(lref, v);
       }
@@ -875,8 +938,8 @@ export 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 = GetValue(propertyNameReference);
     const propertyKey = ToPropertyKey(propertyNameValue);
     return new ReferenceRecord(baseValue, propertyKey, strict);
@@ -914,33 +977,41 @@ export 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 ReferenceRecord) {
       if (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[DebuggerCall];
+      if (debuggerCall) {
+        const result = yield* debuggerCall.apply(thisValue, argList);
+        doSanitize(result);
+        return NormalCompletion(result);
+      }
+    }
     const result = func.apply(thisValue, argList);
-    sanitize(result);
+    doSanitize(result);
     return 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 = GetValue(ref);
-    const argList = ArgumentListEvaluation(args);
+    const argList = yield* ArgumentListEvaluation(args);
     if (typeof constructor !== "function" || constructor[IsConstructor] === false) {
       const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError(`${constructorName} is not a constructor`);
     }
-    if (!isAllowedConstructor(constructor)) {
+    if (!externalSourceForDebug && !isAllowedConstructor(constructor) && constructor !== ArrayConstructor) {
       const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
       throw new TypeError(`${constructorName} is not an allowed constructor`);
     }
@@ -948,32 +1019,43 @@ export 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 = GetValue(Evaluate(arg.argument));
+          const spreadValues = GetValue(yield* Evaluate(arg.argument));
           array.push(...spreadValues);
         } else {
-          array.push(GetValue(Evaluate(arg)));
+          array.push(GetValue(yield* Evaluate(arg)));
         }
       }
     } else {
       array.push(GetTemplateObject(args));
       for (const expr of args.expressions) {
-        array.push(GetValue(Evaluate(expr)));
+        array.push(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[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[SourceNode],
+        [DebuggerReturn]: true
+      };
+      yield {
+        type: "return",
+        value: result.Type === "return" ? result.Value : undefined
+      };
+    }
     executionContextStack.pop();
     if (result.Type === "return") {
       return result.Value;
@@ -985,32 +1067,39 @@ export function cook(rootAst, codeSource) {
   function PrepareForOrdinaryCall(F) {
     const calleeContext = new ExecutionContext();
     calleeContext.Function = F;
-    const localEnv = new FunctionEnvironment(F[Environment]);
+    const localEnv = new FunctionEnvironment(F);
     calleeContext.VariableEnvironment = localEnv;
     calleeContext.LexicalEnvironment = localEnv;
     executionContextStack.push(calleeContext);
     return calleeContext;
   }
+  function OrdinaryCallBindThis(F, calleeContext, thisArgument) {
+    if (F[ThisMode] === 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[ECMAScriptCode], F, args);
+  function* OrdinaryCallEvaluateBody(F, args) {
+    return yield* EvaluateFunctionBody(F[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 CompletionRecord("return", GetValue(Evaluate(body)));
+    return new CompletionRecord("return", GetValue(yield* Evaluate(body)));
   }
 
   // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
-  function EvaluateStatementList(statements) {
+  function* EvaluateStatementList(statements) {
     let result = NormalCompletion(Empty);
     for (const stmt of statements) {
-      const s = Evaluate(stmt);
+      const s = yield* Evaluate(stmt);
       if (s.Type !== "normal") {
         return s;
       }
@@ -1018,9 +1107,39 @@ export 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[ECMAScriptCode];
     const formals = func[FormalParameters];
@@ -1049,20 +1168,44 @@ export 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[ThisMode] !== 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 = 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);
         }
@@ -1075,15 +1218,19 @@ export function cook(rootAst, codeSource) {
       varEnv = new 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;
@@ -1108,40 +1255,78 @@ export 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 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, {
       [SourceNode]: {
@@ -1158,41 +1343,52 @@ export function cook(rootAst, codeSource) {
       },
       [IsConstructor]: {
         value: isConstructor
+      },
+      [ThisMode]: {
+        value: lexicalThis ? Mode.LEXICAL : Mode.STRICT
       }
     });
+    if (debug || externalSourceForDebug) {
+      Object.defineProperty(F, 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":
         RequireObjectCoercible(value);
-        return PropertyBindingInitialization(node.properties, value, environment);
+        return yield* PropertyBindingInitialization(node.properties, value, environment);
       case "ArrayPattern":
         {
           const iteratorRecord = 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);
       }
     }
@@ -1200,8 +1396,8 @@ export function cook(rootAst, codeSource) {
   }
 
   // https://tc39.es/ecma262/#prod-ComputedPropertyName
-  function EvaluateComputedPropertyName(node) {
-    const propName = GetValue(Evaluate(node));
+  function* EvaluateComputedPropertyName(node) {
+    const propName = GetValue(yield* Evaluate(node));
     return ToPropertyKey(propName);
   }
 
@@ -1216,7 +1412,7 @@ export 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 NormalCompletion(Empty);
     }
@@ -1230,7 +1426,7 @@ export 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) {
@@ -1246,7 +1442,7 @@ export function cook(rootAst, codeSource) {
             n++;
           }
         } else {
-          const A = [];
+          const A = new ArrayConstructor();
           let n = 0;
           // eslint-disable-next-line no-constant-condition
           while (true) {
@@ -1255,7 +1451,7 @@ export 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;
@@ -1278,10 +1474,10 @@ export function cook(rootAst, codeSource) {
                 v = value;
               }
               if (node.type === "AssignmentPattern" && v === undefined) {
-                const defaultValue = Evaluate(node.right);
+                const defaultValue = yield* Evaluate(node.right);
                 v = GetValue(defaultValue);
               }
-              result = BindingInitialization(bindingElement, v, environment);
+              result = yield* BindingInitialization(bindingElement, v, environment);
               break;
             }
           case "Identifier":
@@ -1297,9 +1493,12 @@ export function cook(rootAst, codeSource) {
                 v = value;
               }
               if (node.type === "AssignmentPattern" && v === undefined) {
-                // IsAnonymousFunctionDefinition(Initializer)
-                const defaultValue = Evaluate(node.right);
-                v = GetValue(defaultValue);
+                if (IsAnonymousFunctionDefinition(node.right)) {
+                  v = NamedEvaluation(node.right, bindingId);
+                } else {
+                  const defaultValue = yield* Evaluate(node.right);
+                  v = GetValue(defaultValue);
+                }
               }
               result = environment ? InitializeReferencedBinding(lhs, v) : PutValue(lhs, v);
               break;
@@ -1311,16 +1510,19 @@ export 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 = GetV(value, propertyName);
       if (node.type === "AssignmentPattern" && v === undefined) {
-        // If IsAnonymousFunctionDefinition(Initializer)
-        const defaultValue = Evaluate(node.right);
-        v = GetValue(defaultValue);
+        if (IsAnonymousFunctionDefinition(node.right)) {
+          v = NamedEvaluation(node.right, bindingId);
+        } else {
+          const defaultValue = yield* Evaluate(node.right);
+          v = GetValue(defaultValue);
+        }
       }
       if (!environment) {
         return PutValue(lhs, v);
@@ -1329,10 +1531,10 @@ export function cook(rootAst, codeSource) {
     }
     let v = GetV(value, propertyName);
     if (node.type === "AssignmentPattern" && v === undefined) {
-      const defaultValue = Evaluate(node.right);
+      const defaultValue = yield* Evaluate(node.right);
       v = 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
@@ -1350,7 +1552,7 @@ export function cook(rootAst, codeSource) {
     }
   }
   if (expressionOnly) {
-    return GetValue(Evaluate(rootAst));
+    return GetValue(unwind(Evaluate(rootAst)));
   }
   (_hooks$beforeEvaluate3 = hooks.beforeEvaluate) === null || _hooks$beforeEvaluate3 === void 0 || _hooks$beforeEvaluate3.call(hooks, rootAst);
   ThrowIfFunctionIsInvalid(rootAst);
@@ -1359,6 +1561,32 @@ export function cook(rootAst, codeSource) {
   rootEnv.CreateImmutableBinding(fn, true);
   const fo = InstantiateFunctionObject(rootAst, rootEnv);
   rootEnv.InitializeBinding(fn, fo);
+  if (debug) {
+    Object.defineProperties(fo, {
+      [DebuggerScope]: {
+        value: function () {
+          return getRunningContext().LexicalEnvironment;
+        }
+      },
+      [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