@next-core/cook 2.2.18 → 2.3.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, DebuggerScope, DeclarativeEnvironment, ECMAScriptCode, Empty, Environment, ExecutionContext, FormalParameters, FunctionEnvironment, IsConstructor, NormalCompletion, ReferenceRecord, SourceNode } from "./ExecutionContext.js";
 import { sanitize, isAllowedConstructor } from "./sanitize.js";
 import { collectBoundNames, collectScopedDeclarations, containsExpression } from "./traverse.js";
 /** For next-core internal usage only. */
@@ -7,6 +7,7 @@ export function cook(rootAst, codeSource) {
   var _hooks$beforeEvaluate3;
   let {
     rules,
+    debug,
     globalVariables = {},
     hooks = {}
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -41,9 +42,14 @@ 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":
@@ -54,10 +60,10 @@ export function cook(rootAst, codeSource) {
             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 +77,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)).Value;
           const rightValue = GetValue(rightRef);
           if (expressionOnly && node.operator === "|>") {
             // Minimal pipeline operator is supported only in expression-only mode.
@@ -98,21 +104,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);
+          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 +141,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 +160,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);
+          const result = node.computed ? yield* EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
           sanitize(result);
           return NormalCompletion(result);
         }
       case "NewExpression":
         // https://tc39.es/ecma262/#sec-new-operator
-        return EvaluateNew(node.callee, node.arguments);
+        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 +204,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 +214,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 +223,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);
+          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 +262,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 +297,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 +312,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 +333,51 @@ 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);
             }
+            currentNode = node;
             return new CompletionRecord("return", v);
           }
         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 +386,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 +411,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 +421,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 +467,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 +477,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 +491,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 +499,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 +519,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 +535,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 +545,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 +557,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 +584,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 +604,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 +629,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 +642,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 +654,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 +669,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 +710,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 +731,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 +767,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 +791,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 +876,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,9 +886,12 @@ 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;
         }
@@ -865,7 +913,7 @@ export function cook(rootAst, codeSource) {
         }
       }
       if (isObjectOrArray) {
-        status = DestructuringAssignmentEvaluation(assignmentTarget, v);
+        status = yield* DestructuringAssignmentEvaluation(assignmentTarget, v);
       } else {
         status = PutValue(lref, v);
       }
@@ -875,8 +923,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,28 +962,36 @@ 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) {
+      const debuggerCall = func[DebuggerCall];
+      if (debuggerCall) {
+        const result = yield* debuggerCall.apply(thisValue, argList);
+        sanitize(result);
+        return NormalCompletion(result);
+      }
+    }
     const result = func.apply(thisValue, argList);
     sanitize(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`);
@@ -948,32 +1004,39 @@ 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) {
-    var _hooks$beforeCall;
+  function* CallFunction(closure, args) {
+    var _hooks$beforeCall, _currentNode;
     (_hooks$beforeCall = hooks.beforeCall) === null || _hooks$beforeCall === void 0 || _hooks$beforeCall.call(hooks, closure[SourceNode]);
     PrepareForOrdinaryCall(closure);
-    const result = OrdinaryCallEvaluateBody(closure, args);
+    const result = yield* OrdinaryCallEvaluateBody(closure, args);
+    if (((_currentNode = currentNode) === null || _currentNode === void 0 ? void 0 : _currentNode.type) !== "ReturnStatement") {
+      currentNode = closure[SourceNode];
+    }
+    if (debug) yield {
+      type: "return",
+      value: result.Type === "return" ? result.Value : undefined
+    };
     executionContextStack.pop();
     if (result.Type === "return") {
       return result.Value;
@@ -993,24 +1056,24 @@ export function cook(rootAst, codeSource) {
   }
 
   // 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;
       }
@@ -1019,8 +1082,28 @@ export function cook(rootAst, codeSource) {
     return result;
   }
 
+  // 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];
@@ -1055,7 +1138,7 @@ export function cook(rootAst, codeSource) {
       env.CreateMutableBinding(paramName, false);
     }
     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
@@ -1111,37 +1194,50 @@ export function cook(rootAst, codeSource) {
 
   // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatefunctionobject
   function InstantiateFunctionObject(func, scope) {
-    return OrdinaryFunctionCreate(func, scope, true);
+    const F = OrdinaryFunctionCreate(func, scope, true);
+    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);
+      SetFunctionName(closure, name);
       funcEnv.InitializeBinding(name, closure);
       return closure;
     } else {
       const closure = OrdinaryFunctionCreate(functionExpression, scope, true);
+      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);
+    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) {
     const F = function () {
       // eslint-disable-next-line prefer-rest-params
-      return CallFunction(F, arguments);
+      return unwind(CallFunction(F, arguments));
     };
     Object.defineProperties(F, {
       [SourceNode]: {
@@ -1160,39 +1256,47 @@ export function cook(rootAst, codeSource) {
         value: isConstructor
       }
     });
+    if (debug) {
+      Object.defineProperty(F, DebuggerCall, {
+        value: function () {
+          // eslint-disable-next-line prefer-rest-params
+          return CallFunction(F, 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 +1304,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 +1320,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);
     }
@@ -1255,7 +1359,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 +1382,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 +1401,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 +1418,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 +1439,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 +1460,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 +1469,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