@next-core/cook 1.0.1

package/dist/cjs/cook.js

@@ -0,0 +1,1587 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cook = cook;
+
+var _contextFree = require("./context-free");
+
+var _ExecutionContext = require("./ExecutionContext");
+
+var _sanitize = require("./sanitize");
+
+var _traverse = require("./traverse");
+
+/** For next-core internal usage only. */
+function cook(rootAst, codeSource, {
+  rules,
+  globalVariables = {}
+} = {}) {
+  const expressionOnly = rootAst.type !== "FunctionDeclaration";
+  const rootEnv = new _ExecutionContext.DeclarativeEnvironment(null);
+  const rootContext = new _ExecutionContext.ExecutionContext();
+  rootContext.VariableEnvironment = rootEnv;
+  rootContext.LexicalEnvironment = rootEnv;
+  const executionContextStack = [rootContext];
+
+  for (const [key, value] of Object.entries(globalVariables)) {
+    rootEnv.CreateImmutableBinding(key, true);
+    rootEnv.InitializeBinding(key, value);
+  }
+
+  const TemplateMap = new WeakMap(); // https://tc39.es/ecma262/#sec-gettemplateobject
+
+  function GetTemplateObject(templateLiteral) {
+    const memo = TemplateMap.get(templateLiteral);
+
+    if (memo) {
+      return memo;
+    }
+
+    const rawObj = templateLiteral.quasis.map(quasi => quasi.value.raw);
+    const template = templateLiteral.quasis.map(quasi => quasi.value.cooked);
+    Object.freeze(rawObj);
+    Object.defineProperty(template, "raw", {
+      value: rawObj,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    Object.freeze(template);
+    TemplateMap.set(templateLiteral, template);
+    return template;
+  }
+
+  function Evaluate(node, optionalChainRef) {
+    // Expressions:
+    switch (node.type) {
+      case "ArrayExpression":
+        {
+          // https://tc39.es/ecma262/#sec-array-initializer
+          const array = [];
+
+          for (const element of node.elements) {
+            if (!element) {
+              array.length += 1;
+            } else if (element.type === "SpreadElement") {
+              const spreadValues = (0, _contextFree.GetValue)(Evaluate(element.argument));
+              array.push(...spreadValues);
+            } else {
+              array.push((0, _contextFree.GetValue)(Evaluate(element)));
+            }
+          }
+
+          return (0, _ExecutionContext.NormalCompletion)(array);
+        }
+
+      case "ArrowFunctionExpression":
+        {
+          // https://tc39.es/ecma262/#sec-arrow-function-definitions
+          ThrowIfFunctionIsInvalid(node);
+          const closure = InstantiateArrowFunctionExpression(node);
+          return (0, _ExecutionContext.NormalCompletion)(closure);
+        }
+
+      case "BinaryExpression":
+        {
+          const leftRef = Evaluate(node.left);
+          const leftValue = (0, _contextFree.GetValue)(leftRef);
+          const rightRef = Evaluate(node.right).Value;
+          const rightValue = (0, _contextFree.GetValue)(rightRef);
+
+          if (expressionOnly && node.operator === "|>") {
+            // Minimal pipeline operator is supported only in expression-only mode.
+            // See https://tc39.es/proposal-pipeline-operator
+            // and https://github.com/tc39/proposal-pipeline-operator
+            if (typeof rightValue !== "function") {
+              const funcName = codeSource.substring(node.right.start, node.right.end);
+              throw new TypeError(`${funcName} is not a function`);
+            }
+
+            let thisValue;
+
+            if (rightRef instanceof _ExecutionContext.ReferenceRecord) {
+              if ((0, _contextFree.IsPropertyReference)(rightRef)) {
+                thisValue = rightRef.Base;
+              }
+            }
+
+            return (0, _ExecutionContext.NormalCompletion)(rightValue.call(thisValue, leftValue));
+          } // https://tc39.es/ecma262/#sec-additive-operators
+
+
+          const result = (0, _contextFree.ApplyStringOrNumericBinaryOperator)(leftValue, node.operator, rightValue);
+          return (0, _ExecutionContext.NormalCompletion)(result);
+        }
+
+      case "CallExpression":
+        {
+          // https://tc39.es/ecma262/#sec-function-calls
+          const ref = Evaluate(node.callee, optionalChainRef).Value;
+          const func = (0, _contextFree.GetValue)(ref);
+
+          if ((func === undefined || func === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
+            optionalChainRef.skipped = true;
+            return (0, _ExecutionContext.NormalCompletion)(undefined);
+          }
+
+          (0, _sanitize.sanitize)(func);
+          return EvaluateCall(func, ref, node.arguments, node.callee);
+        }
+
+      case "ChainExpression":
+        // https://tc39.es/ecma262/#sec-optional-chains
+        return Evaluate(node.expression, {});
+
+      case "ConditionalExpression":
+        // https://tc39.es/ecma262/#sec-conditional-operator
+        return (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(Evaluate((0, _contextFree.GetValue)(Evaluate(node.test)) ? node.consequent : node.alternate)));
+
+      case "Identifier":
+        // https://tc39.es/ecma262/#sec-identifiers
+        return (0, _ExecutionContext.NormalCompletion)(ResolveBinding(node.name));
+
+      case "Literal":
+        {
+          // https://tc39.es/ecma262/#sec-primary-expression-literals
+          if (node.regex) {
+            if (node.value === null) {
+              // Invalid regular expression fails silently in @babel/parser.
+              throw new SyntaxError(`Invalid regular expression: ${node.raw}`);
+            }
+
+            if (node.regex.flags.includes("u")) {
+              // Currently unicode flag is not fully supported across major browsers.
+              throw new SyntaxError(`Unsupported unicode flag in regular expression: ${node.raw}`);
+            }
+          }
+
+          return (0, _ExecutionContext.NormalCompletion)(node.value);
+        }
+
+      case "LogicalExpression":
+        {
+          // https://tc39.es/ecma262/#sec-binary-logical-operators
+          const leftValue = (0, _contextFree.GetValue)(Evaluate(node.left));
+
+          switch (node.operator) {
+            case "&&":
+              return (0, _ExecutionContext.NormalCompletion)(leftValue && (0, _contextFree.GetValue)(Evaluate(node.right)));
+
+            case "||":
+              return (0, _ExecutionContext.NormalCompletion)(leftValue || (0, _contextFree.GetValue)(Evaluate(node.right)));
+
+            case "??":
+              return (0, _ExecutionContext.NormalCompletion)(leftValue !== null && leftValue !== void 0 ? leftValue : (0, _contextFree.GetValue)(Evaluate(node.right)));
+            // istanbul ignore next
+
+            default:
+              throw new SyntaxError( // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore never reach here.
+              `Unsupported logical operator '${node.operator}'`);
+          }
+        }
+
+      case "MemberExpression":
+        {
+          // https://tc39.es/ecma262/#sec-property-accessors
+          const baseReference = Evaluate(node.object, optionalChainRef).Value;
+          const baseValue = (0, _contextFree.GetValue)(baseReference);
+
+          if ((baseValue === undefined || baseValue === null) && (node.optional || optionalChainRef !== null && optionalChainRef !== void 0 && optionalChainRef.skipped)) {
+            optionalChainRef.skipped = true;
+            return (0, _ExecutionContext.NormalCompletion)(undefined);
+          }
+
+          (0, _sanitize.sanitize)(baseValue);
+          const result = node.computed ? EvaluatePropertyAccessWithExpressionKey(baseValue, node.property, true) : EvaluatePropertyAccessWithIdentifierKey(baseValue, node.property, true);
+          (0, _sanitize.sanitize)(result);
+          return (0, _ExecutionContext.NormalCompletion)(result);
+        }
+
+      case "NewExpression":
+        // https://tc39.es/ecma262/#sec-new-operator
+        return EvaluateNew(node.callee, node.arguments);
+
+      case "ObjectExpression":
+        {
+          // https://tc39.es/ecma262/#sec-object-initializer
+          const object = {};
+
+          for (const prop of node.properties) {
+            if (prop.type === "SpreadElement") {
+              const fromValue = (0, _contextFree.GetValue)(Evaluate(prop.argument));
+              (0, _contextFree.CopyDataProperties)(object, fromValue, new Set());
+            } else {
+              if (prop.kind !== "init") {
+                throw new SyntaxError("Unsupported object getter/setter");
+              }
+
+              const propName = !prop.computed && prop.key.type === "Identifier" ? prop.key.name : EvaluateComputedPropertyName(prop.key);
+
+              if (propName === "__proto__") {
+                throw new TypeError("Setting '__proto__' property is not allowed");
+              }
+
+              object[propName] = (0, _contextFree.GetValue)(Evaluate(prop.value));
+            }
+          }
+
+          return (0, _ExecutionContext.NormalCompletion)(object);
+        }
+
+      case "SequenceExpression":
+        {
+          // https://tc39.es/ecma262/#sec-comma-operator
+          let result;
+
+          for (const expr of node.expressions) {
+            result = (0, _ExecutionContext.NormalCompletion)((0, _contextFree.GetValue)(Evaluate(expr)));
+          }
+
+          return result;
+        }
+
+      case "TemplateLiteral":
+        {
+          // https://tc39.es/ecma262/#sec-template-literals
+          const chunks = [node.quasis[0].value.cooked];
+          let index = 0;
+
+          for (const expr of node.expressions) {
+            const val = (0, _contextFree.GetValue)(Evaluate(expr));
+            chunks.push(String(val));
+            chunks.push(node.quasis[index += 1].value.cooked);
+          }
+
+          return (0, _ExecutionContext.NormalCompletion)(chunks.join(""));
+        }
+
+      case "TaggedTemplateExpression":
+        {
+          // https://tc39.es/ecma262/#sec-tagged-templates
+          const tagRef = Evaluate(node.tag).Value;
+          const tagFunc = (0, _contextFree.GetValue)(tagRef);
+          (0, _sanitize.sanitize)(tagFunc);
+          return EvaluateCall(tagFunc, tagRef, node.quasi, node.tag);
+        }
+
+      case "UnaryExpression":
+        {
+          // https://tc39.es/ecma262/#sec-unary-operators
+          const ref = Evaluate(node.argument).Value;
+
+          if (!expressionOnly && node.operator === "delete") {
+            // Delete operator is supported only in function mode.
+            if (!(ref instanceof _ExecutionContext.ReferenceRecord)) {
+              return (0, _ExecutionContext.NormalCompletion)(true);
+            } // istanbul ignore else
+
+
+            if ((0, _contextFree.IsPropertyReference)(ref)) {
+              const deleteStatus = delete ref.Base[ref.ReferenceName];
+              return (0, _ExecutionContext.NormalCompletion)(deleteStatus);
+            } // Should never reach here in strict mode.
+
+          }
+
+          if (node.operator === "typeof") {
+            if (ref instanceof _ExecutionContext.ReferenceRecord && ref.Base === "unresolvable") {
+              return (0, _ExecutionContext.NormalCompletion)("undefined");
+            }
+
+            return (0, _ExecutionContext.NormalCompletion)(typeof (0, _contextFree.GetValue)(ref));
+          }
+
+          return (0, _ExecutionContext.NormalCompletion)((0, _contextFree.ApplyUnaryOperator)((0, _contextFree.GetValue)(ref), node.operator));
+        }
+    }
+
+    if (!expressionOnly) {
+      // Statements and assignments:
+      switch (node.type) {
+        case "AssignmentExpression":
+          {
+            // https://tc39.es/ecma262/#sec-assignment-operators
+            if (node.operator === "=") {
+              if (!(node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern")) {
+                const lref = Evaluate(node.left).Value; // Todo: IsAnonymousFunctionDefinition(lref)
+
+                const rref = Evaluate(node.right);
+                const rval = (0, _contextFree.GetValue)(rref);
+                (0, _contextFree.PutValue)(lref, rval);
+                return (0, _ExecutionContext.NormalCompletion)(rval);
+              }
+
+              const rref = Evaluate(node.right);
+              const rval = (0, _contextFree.GetValue)(rref);
+              DestructuringAssignmentEvaluation(node.left, rval);
+              return (0, _ExecutionContext.NormalCompletion)(rval);
+            } // Operators other than `=`.
+
+
+            const lref = Evaluate(node.left).Value;
+            const lval = (0, _contextFree.GetValue)(lref);
+            const rref = Evaluate(node.right);
+            const rval = (0, _contextFree.GetValue)(rref);
+            const r = (0, _contextFree.ApplyStringOrNumericAssignment)(lval, node.operator, rval);
+            (0, _contextFree.PutValue)(lref, r);
+            return (0, _ExecutionContext.NormalCompletion)(r);
+          }
+
+        case "BlockStatement":
+          {
+            // https://tc39.es/ecma262/#sec-block
+            if (!node.body.length) {
+              return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+            }
+
+            const oldEnv = getRunningContext().LexicalEnvironment;
+            const blockEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
+            BlockDeclarationInstantiation(node.body, blockEnv);
+            getRunningContext().LexicalEnvironment = blockEnv;
+            const blockValue = EvaluateStatementList(node.body);
+            getRunningContext().LexicalEnvironment = oldEnv;
+            return blockValue;
+          }
+
+        case "BreakStatement":
+          // https://tc39.es/ecma262/#sec-break-statement
+          return new _ExecutionContext.CompletionRecord("break", _ExecutionContext.Empty);
+
+        case "ContinueStatement":
+          // https://tc39.es/ecma262/#sec-continue-statement
+          return new _ExecutionContext.CompletionRecord("continue", _ExecutionContext.Empty);
+
+        case "EmptyStatement":
+          // https://tc39.es/ecma262/#sec-empty-statement
+          return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+
+        case "DoWhileStatement":
+          // https://tc39.es/ecma262/#sec-do-while-statement
+          return EvaluateBreakableStatement(DoWhileLoopEvaluation(node));
+
+        case "ExpressionStatement":
+        case "TSAsExpression":
+          // https://tc39.es/ecma262/#sec-expression-statement
+          return Evaluate(node.expression);
+
+        case "ForInStatement":
+        case "ForOfStatement":
+          // https://tc39.es/ecma262/#sec-for-in-and-for-of-statements
+          return EvaluateBreakableStatement(ForInOfLoopEvaluation(node));
+
+        case "ForStatement":
+          // https://tc39.es/ecma262/#sec-for-statement
+          return EvaluateBreakableStatement(ForLoopEvaluation(node));
+
+        case "FunctionDeclaration":
+          // https://tc39.es/ecma262/#sec-function-definitions
+          return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+
+        case "FunctionExpression":
+          // https://tc39.es/ecma262/#sec-function-defining-expressions
+          ThrowIfFunctionIsInvalid(node);
+          return (0, _ExecutionContext.NormalCompletion)(InstantiateOrdinaryFunctionExpression(node));
+
+        case "IfStatement":
+          // https://tc39.es/ecma262/#sec-if-statement
+          return (0, _contextFree.GetValue)(Evaluate(node.test)) ? (0, _contextFree.UpdateEmpty)(Evaluate(node.consequent), undefined) : node.alternate ? (0, _contextFree.UpdateEmpty)(Evaluate(node.alternate), undefined) : (0, _ExecutionContext.NormalCompletion)(undefined);
+
+        case "ReturnStatement":
+          {
+            // https://tc39.es/ecma262/#sec-return-statement
+            let v;
+
+            if (node.argument) {
+              const exprRef = Evaluate(node.argument);
+              v = (0, _contextFree.GetValue)(exprRef);
+            }
+
+            return new _ExecutionContext.CompletionRecord("return", v);
+          }
+
+        case "ThrowStatement":
+          // https://tc39.es/ecma262/#sec-throw-statement
+          throw (0, _contextFree.GetValue)(Evaluate(node.argument));
+
+        case "UpdateExpression":
+          {
+            // https://tc39.es/ecma262/#sec-update-expressions
+            const lhs = Evaluate(node.argument).Value;
+            const oldValue = Number((0, _contextFree.GetValue)(lhs));
+            const newValue = node.operator === "++" ? oldValue + 1 : oldValue - 1;
+            (0, _contextFree.PutValue)(lhs, newValue);
+            return (0, _ExecutionContext.NormalCompletion)(node.prefix ? newValue : oldValue);
+          }
+
+        case "SwitchCase":
+          return EvaluateStatementList(node.consequent);
+
+        case "SwitchStatement":
+          {
+            // https://tc39.es/ecma262/#sec-switch-statement
+            const exprRef = Evaluate(node.discriminant);
+            const switchValue = (0, _contextFree.GetValue)(exprRef);
+            const oldEnv = getRunningContext().LexicalEnvironment;
+            const blockEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
+            BlockDeclarationInstantiation(node.cases, blockEnv);
+            getRunningContext().LexicalEnvironment = blockEnv;
+            const R = CaseBlockEvaluation(node.cases, switchValue);
+            getRunningContext().LexicalEnvironment = oldEnv;
+            return EvaluateBreakableStatement(R);
+          }
+
+        case "TryStatement":
+          {
+            // https://tc39.es/ecma262/#sec-try-statement
+            let R;
+
+            try {
+              R = Evaluate(node.block);
+            } catch (error) {
+              if (node.handler) {
+                R = CatchClauseEvaluation(node.handler, error);
+              } else {
+                throw error;
+              }
+            } finally {
+              if (node.finalizer) {
+                const F = Evaluate(node.finalizer);
+
+                if (F.Type !== "normal") {
+                  R = F;
+                }
+              }
+            }
+
+            return R;
+          }
+
+        case "VariableDeclaration":
+          {
+            // https://tc39.es/ecma262/#sec-declarations-and-the-variable-statement
+            let result;
+
+            for (const declarator of node.declarations) {
+              if (!declarator.init) {
+                // Assert: a declarator without init is always an identifier.
+                if (node.kind === "var") {
+                  result = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+                } else {
+                  const lhs = ResolveBinding(declarator.id.name);
+                  result = (0, _contextFree.InitializeReferencedBinding)(lhs, undefined);
+                }
+              } else if (declarator.id.type === "Identifier") {
+                const bindingId = declarator.id.name;
+                const lhs = ResolveBinding(bindingId); // Todo: IsAnonymousFunctionDefinition(Initializer)
+
+                const rhs = Evaluate(declarator.init);
+                const value = (0, _contextFree.GetValue)(rhs);
+                result = node.kind === "var" ? (0, _contextFree.PutValue)(lhs, value) : (0, _contextFree.InitializeReferencedBinding)(lhs, value);
+              } else {
+                const rhs = Evaluate(declarator.init);
+                const rval = (0, _contextFree.GetValue)(rhs);
+                result = 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));
+      }
+    } // eslint-disable-next-line no-console
+
+
+    throw new SyntaxError(`Unsupported node type \`${node.type}\``);
+  } // https://tc39.es/ecma262/#sec-execution-contexts
+
+
+  function getRunningContext() {
+    return executionContextStack[executionContextStack.length - 1];
+  } // https://tc39.es/ecma262/#sec-resolvebinding
+
+
+  function ResolveBinding(name, env) {
+    if (!env) {
+      env = getRunningContext().LexicalEnvironment;
+    }
+
+    return (0, _contextFree.GetIdentifierReference)(env, name, true);
+  } // Try statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation
+
+
+  function CatchClauseEvaluation(node, thrownValue) {
+    const oldEnv = getRunningContext().LexicalEnvironment;
+    const catchEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
+
+    for (const argName of (0, _traverse.collectBoundNames)(node.param)) {
+      catchEnv.CreateMutableBinding(argName, false);
+    }
+
+    getRunningContext().LexicalEnvironment = catchEnv;
+    BindingInitialization(node.param, thrownValue, catchEnv);
+    const B = Evaluate(node.body);
+    getRunningContext().LexicalEnvironment = oldEnv;
+    return B;
+  } // Iteration statements and switch statements.
+  // https://tc39.es/ecma262/#prod-BreakableStatement
+
+
+  function EvaluateBreakableStatement(stmtResult) {
+    return stmtResult.Type === "break" ? stmtResult.Value === _ExecutionContext.Empty ? (0, _ExecutionContext.NormalCompletion)(undefined) : (0, _ExecutionContext.NormalCompletion)(stmtResult.Value) : stmtResult;
+  } // Switch statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
+
+
+  function CaseBlockEvaluation(cases, input) {
+    let V;
+    const defaultCaseIndex = cases.findIndex(switchCase => !switchCase.test);
+    const hasDefaultCase = defaultCaseIndex >= 0;
+    const A = hasDefaultCase ? cases.slice(0, defaultCaseIndex) : cases;
+    let found = false;
+
+    for (const C of A) {
+      if (!found) {
+        found = CaseClauseIsSelected(C, input);
+      }
+
+      if (found) {
+        const R = Evaluate(C);
+
+        if (R.Value !== _ExecutionContext.Empty) {
+          V = R.Value;
+        }
+
+        if (R.Type !== "normal") {
+          return (0, _contextFree.UpdateEmpty)(R, V);
+        }
+      }
+    }
+
+    if (!hasDefaultCase) {
+      return (0, _ExecutionContext.NormalCompletion)(V);
+    }
+
+    let foundInB = false;
+    const B = cases.slice(defaultCaseIndex + 1);
+
+    if (!found) {
+      for (const C of B) {
+        if (!foundInB) {
+          foundInB = CaseClauseIsSelected(C, input);
+        }
+
+        if (foundInB) {
+          const R = Evaluate(C);
+
+          if (R.Value !== _ExecutionContext.Empty) {
+            V = R.Value;
+          }
+
+          if (R.Type !== "normal") {
+            return (0, _contextFree.UpdateEmpty)(R, V);
+          }
+        }
+      }
+    }
+
+    if (foundInB) {
+      return (0, _ExecutionContext.NormalCompletion)(V);
+    }
+
+    const R = Evaluate(cases[defaultCaseIndex]);
+
+    if (R.Value !== _ExecutionContext.Empty) {
+      V = R.Value;
+    }
+
+    if (R.Type !== "normal") {
+      return (0, _contextFree.UpdateEmpty)(R, V);
+    } // NOTE: The following is another complete iteration of the second CaseClauses.
+
+
+    for (const C of B) {
+      const R = Evaluate(C);
+
+      if (R.Value !== _ExecutionContext.Empty) {
+        V = R.Value;
+      }
+
+      if (R.Type !== "normal") {
+        return (0, _contextFree.UpdateEmpty)(R, V);
+      }
+    }
+
+    return (0, _ExecutionContext.NormalCompletion)(V);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
+
+
+  function CaseClauseIsSelected(C, input) {
+    const clauseSelector = (0, _contextFree.GetValue)(Evaluate(C.test));
+    return input === clauseSelector;
+  } // While statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-whileloopevaluation
+
+
+  function WhileLoopEvaluation(node) {
+    let V; // eslint-disable-next-line no-constant-condition
+
+    while (true) {
+      const exprValue = (0, _contextFree.GetValue)(Evaluate(node.test));
+
+      if (!exprValue) {
+        return (0, _ExecutionContext.NormalCompletion)(V);
+      }
+
+      const stmtResult = Evaluate(node.body);
+
+      if (!(0, _contextFree.LoopContinues)(stmtResult)) {
+        return (0, _contextFree.UpdateEmpty)(stmtResult, V);
+      }
+
+      if (stmtResult.Value !== _ExecutionContext.Empty) {
+        V = stmtResult.Value;
+      }
+    }
+  } // Do-while Statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-dowhileloopevaluation
+
+
+  function DoWhileLoopEvaluation(node) {
+    let V; // eslint-disable-next-line no-constant-condition
+
+    while (true) {
+      const stmtResult = Evaluate(node.body);
+
+      if (!(0, _contextFree.LoopContinues)(stmtResult)) {
+        return (0, _contextFree.UpdateEmpty)(stmtResult, V);
+      }
+
+      if (stmtResult.Value !== _ExecutionContext.Empty) {
+        V = stmtResult.Value;
+      }
+
+      const exprValue = (0, _contextFree.GetValue)(Evaluate(node.test));
+
+      if (!exprValue) {
+        return (0, _ExecutionContext.NormalCompletion)(V);
+      }
+    }
+  } // For in/of statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
+
+
+  function ForInOfLoopEvaluation(node) {
+    const lhs = node.left;
+    const isVariableDeclaration = lhs.type === "VariableDeclaration";
+    const lhsKind = isVariableDeclaration ? lhs.kind === "var" ? "varBinding" : "lexicalBinding" : "assignment";
+    const uninitializedBoundNames = lhsKind === "lexicalBinding" ? (0, _traverse.collectBoundNames)(lhs) : [];
+    const iterationKind = node.type === "ForInStatement" ? "enumerate" : "iterate";
+    const keyResult = ForInOfHeadEvaluation(uninitializedBoundNames, node.right, iterationKind);
+
+    if (keyResult.Type !== "normal") {
+      // When enumerate, if the target is nil, a break completion will be returned.
+      return keyResult;
+    }
+
+    return ForInOfBodyEvaluation(lhs, node.body, keyResult.Value, iterationKind, lhsKind);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
+
+
+  function ForInOfHeadEvaluation(uninitializedBoundNames, expr, iterationKind) {
+    const runningContext = getRunningContext();
+    const oldEnv = runningContext.LexicalEnvironment;
+
+    if (uninitializedBoundNames.length > 0) {
+      const newEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
+
+      for (const name of uninitializedBoundNames) {
+        newEnv.CreateMutableBinding(name, false);
+      }
+
+      runningContext.LexicalEnvironment = newEnv;
+    }
+
+    const exprRef = Evaluate(expr);
+    runningContext.LexicalEnvironment = oldEnv;
+    const exprValue = (0, _contextFree.GetValue)(exprRef);
+
+    if (iterationKind === "enumerate") {
+      if (exprValue === null || exprValue === undefined) {
+        return new _ExecutionContext.CompletionRecord("break", _ExecutionContext.Empty);
+      }
+
+      const iterator = EnumerateObjectProperties(exprValue);
+      return (0, _ExecutionContext.NormalCompletion)(iterator);
+    }
+
+    const iterator = (0, _contextFree.CreateListIteratorRecord)(exprValue);
+    return (0, _ExecutionContext.NormalCompletion)(iterator);
+  }
+
+  function ForInOfBodyEvaluation(node, stmt, iteratorRecord, iterationKind, lhsKind) {
+    const lhs = lhsKind === "assignment" ? node : node.declarations[0].id;
+    const oldEnv = getRunningContext().LexicalEnvironment;
+    let V; // When `destructuring` is false,
+    // For `node` whose `kind` is assignment:
+    //   `lhs` is an `Identifier` or a `MemberExpression`,
+    // Otherwise:
+    //   `lhs` is an `Identifier`.
+
+    const destructuring = lhs.type === "ObjectPattern" || lhs.type === "ArrayPattern"; // eslint-disable-next-line no-constant-condition
+
+    while (true) {
+      const {
+        done,
+        value: nextValue
+      } = iteratorRecord.next();
+
+      if (done) {
+        return (0, _ExecutionContext.NormalCompletion)(V);
+      }
+
+      let lhsRef;
+      let iterationEnv;
+
+      if (lhsKind === "lexicalBinding") {
+        iterationEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
+        (0, _contextFree.ForDeclarationBindingInstantiation)(node, iterationEnv);
+        getRunningContext().LexicalEnvironment = iterationEnv;
+
+        if (!destructuring) {
+          const [lhsName] = (0, _traverse.collectBoundNames)(lhs);
+          lhsRef = ResolveBinding(lhsName);
+        }
+      } else if (!destructuring) {
+        lhsRef = Evaluate(lhs).Value;
+      }
+
+      destructuring ? lhsKind === "assignment" ? DestructuringAssignmentEvaluation(lhs, nextValue) : lhsKind === "varBinding" ? BindingInitialization(lhs, nextValue, undefined) : BindingInitialization(lhs, nextValue, iterationEnv) : lhsKind === "lexicalBinding" ? (0, _contextFree.InitializeReferencedBinding)(lhsRef, nextValue) : (0, _contextFree.PutValue)(lhsRef, nextValue);
+      const result = Evaluate(stmt);
+      getRunningContext().LexicalEnvironment = oldEnv;
+
+      if (!(0, _contextFree.LoopContinues)(result)) {
+        return (0, _contextFree.UpdateEmpty)(result, V);
+      }
+
+      if (result.Value !== _ExecutionContext.Empty) {
+        V = result.Value;
+      }
+    }
+  } // https://tc39.es/ecma262/#sec-enumerate-object-properties
+
+
+  function* EnumerateObjectProperties(value) {
+    for (const key in value) {
+      yield key;
+    }
+  } // For statements.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-forloopevaluation
+
+
+  function ForLoopEvaluation(node) {
+    var _node$init;
+
+    if (((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) === "VariableDeclaration") {
+      // `for (var … ; … ; … ) …`
+      if (node.init.kind === "var") {
+        Evaluate(node.init);
+        return ForBodyEvaluation(node.test, node.update, node.body, []);
+      } // `for (let/const … ; … ; … ) …`
+
+
+      const oldEnv = getRunningContext().LexicalEnvironment;
+      const loopEnv = new _ExecutionContext.DeclarativeEnvironment(oldEnv);
+      const isConst = node.init.kind === "const";
+      const boundNames = (0, _traverse.collectBoundNames)(node.init);
+
+      for (const dn of boundNames) {
+        if (isConst) {
+          loopEnv.CreateImmutableBinding(dn, true);
+        } else {
+          loopEnv.CreateMutableBinding(dn, false);
+        }
+      }
+
+      getRunningContext().LexicalEnvironment = loopEnv;
+      Evaluate(node.init);
+      const perIterationLets = isConst ? [] : Array.from(boundNames);
+      const bodyResult = ForBodyEvaluation(node.test, node.update, node.body, perIterationLets);
+      getRunningContext().LexicalEnvironment = oldEnv;
+      return bodyResult;
+    } // `for ( … ; … ; … ) …`
+
+
+    if (node.init) {
+      const exprRef = Evaluate(node.init);
+      (0, _contextFree.GetValue)(exprRef);
+    }
+
+    return ForBodyEvaluation(node.test, node.update, node.body, []);
+  } // https://tc39.es/ecma262/#sec-forbodyevaluation
+
+
+  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 testValue = (0, _contextFree.GetValue)(testRef);
+
+        if (!testValue) {
+          return (0, _ExecutionContext.NormalCompletion)(V);
+        }
+      }
+
+      const result = Evaluate(stmt);
+
+      if (!(0, _contextFree.LoopContinues)(result)) {
+        return (0, _contextFree.UpdateEmpty)(result, V);
+      }
+
+      if (result.Value) {
+        V = result.Value;
+      }
+
+      CreatePerIterationEnvironment(perIterationBindings);
+
+      if (increment) {
+        const incRef = Evaluate(increment);
+        (0, _contextFree.GetValue)(incRef);
+      }
+    }
+  } // https://tc39.es/ecma262/#sec-createperiterationenvironment
+
+
+  function CreatePerIterationEnvironment(perIterationBindings) {
+    if (perIterationBindings.length === 0) {
+      return;
+    }
+
+    const lastIterationEnv = getRunningContext().LexicalEnvironment;
+    const outer = lastIterationEnv.OuterEnv;
+    const thisIterationEnv = new _ExecutionContext.DeclarativeEnvironment(outer);
+
+    for (const bn of perIterationBindings) {
+      thisIterationEnv.CreateMutableBinding(bn, false);
+      const lastValue = lastIterationEnv.GetBindingValue(bn, false);
+      thisIterationEnv.InitializeBinding(bn, lastValue);
+    }
+
+    getRunningContext().LexicalEnvironment = thisIterationEnv;
+  } // Destructuring assignments.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-destructuringassignmentevaluation
+
+
+  function DestructuringAssignmentEvaluation(pattern, value) {
+    if (pattern.type === "ObjectPattern") {
+      (0, _contextFree.RequireObjectCoercible)(value);
+
+      if (pattern.properties.length > 0) {
+        PropertyDestructuringAssignmentEvaluation(pattern.properties, value);
+      }
+
+      return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+    }
+
+    const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(value);
+    return IteratorDestructuringAssignmentEvaluation(pattern.elements, iteratorRecord);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-propertydestructuringassignmentevaluation
+
+
+  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 valueTarget = prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value;
+
+        if (valueTarget.type === "Identifier") {
+          const lref = ResolveBinding(valueTarget.name);
+          let v = (0, _contextFree.GetV)(value, propName);
+
+          if (prop.value.type === "AssignmentPattern" && v === undefined) {
+            // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
+            const defaultValue = Evaluate(prop.value.right);
+            v = (0, _contextFree.GetValue)(defaultValue);
+          }
+
+          (0, _contextFree.PutValue)(lref, v);
+          excludedNames.add(propName);
+        } else {
+          KeyedDestructuringAssignmentEvaluation(prop.value, value, propName);
+          excludedNames.add(propName);
+        }
+      } else {
+        RestDestructuringAssignmentEvaluation(prop, value, excludedNames);
+      }
+    }
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-keyeddestructuringassignmentevaluation
+
+
+  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;
+    }
+
+    const v = (0, _contextFree.GetV)(value, propertyName);
+    let rhsValue;
+
+    if (node.type === "AssignmentPattern" && v === undefined) {
+      // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
+      const defaultValue = Evaluate(node.right);
+      rhsValue = (0, _contextFree.GetValue)(defaultValue);
+    } else {
+      rhsValue = v;
+    }
+
+    if (isObjectOrArray) {
+      return DestructuringAssignmentEvaluation(assignmentTarget, rhsValue);
+    }
+
+    return (0, _contextFree.PutValue)(lref, rhsValue);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation
+
+
+  function RestDestructuringAssignmentEvaluation(restProperty, value, excludedNames) {
+    const lref = Evaluate(restProperty.argument).Value;
+    const restObj = (0, _contextFree.CopyDataProperties)({}, value, excludedNames);
+    return (0, _contextFree.PutValue)(lref, restObj);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-iteratordestructuringassignmentevaluation
+
+
+  function IteratorDestructuringAssignmentEvaluation(elements, iteratorRecord) {
+    let status = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+
+    for (const element of elements) {
+      if (!element) {
+        iteratorRecord.next();
+        status = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+        continue;
+      }
+
+      const assignmentTarget = element.type === "RestElement" ? element.argument : element.type === "AssignmentPattern" ? element.left : element;
+      const isObjectOrArray = assignmentTarget.type === "ArrayPattern" || assignmentTarget.type === "ObjectPattern";
+      let lref;
+
+      if (!isObjectOrArray) {
+        lref = Evaluate(assignmentTarget).Value;
+      }
+
+      let v;
+
+      if (element.type !== "RestElement") {
+        const {
+          done,
+          value: nextValue
+        } = iteratorRecord.next();
+        const value = done ? undefined : nextValue;
+
+        if (element.type === "AssignmentPattern" && value === undefined) {
+          // Todo(steve): check IsAnonymousFunctionDefinition(Initializer)
+          const defaultValue = Evaluate(element.right);
+          v = (0, _contextFree.GetValue)(defaultValue);
+        } else {
+          v = value;
+        }
+      } else {
+        // RestElement
+        v = [];
+        let n = 0; // eslint-disable-next-line no-constant-condition
+
+        while (true) {
+          const {
+            done,
+            value: nextValue
+          } = iteratorRecord.next();
+
+          if (done) {
+            break;
+          }
+
+          v[n] = nextValue;
+          n++;
+        }
+      }
+
+      if (isObjectOrArray) {
+        status = DestructuringAssignmentEvaluation(assignmentTarget, v);
+      } else {
+        status = (0, _contextFree.PutValue)(lref, v);
+      }
+    }
+
+    return status;
+  } // Object expressions.
+  // https://tc39.es/ecma262/#sec-evaluate-property-access-with-expression-key
+
+
+  function EvaluatePropertyAccessWithExpressionKey(baseValue, expression, strict) {
+    const propertyNameReference = Evaluate(expression);
+    const propertyNameValue = (0, _contextFree.GetValue)(propertyNameReference);
+    const propertyKey = (0, _contextFree.ToPropertyKey)(propertyNameValue);
+    return new _ExecutionContext.ReferenceRecord(baseValue, propertyKey, strict);
+  } // https://tc39.es/ecma262/#sec-evaluate-property-access-with-identifier-key
+
+
+  function EvaluatePropertyAccessWithIdentifierKey(baseValue, identifier, strict) {
+    const propertyNameString = identifier.name;
+    return new _ExecutionContext.ReferenceRecord(baseValue, propertyNameString, strict);
+  } // Block statements.
+  // https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
+
+
+  function BlockDeclarationInstantiation(code, env) {
+    const declarations = (0, _traverse.collectScopedDeclarations)(code, {
+      var: false,
+      topLevel: false
+    });
+
+    for (const d of declarations) {
+      const IsConstantDeclaration = d.type === "VariableDeclaration" && d.kind === "const";
+
+      for (const dn of (0, _traverse.collectBoundNames)(d)) {
+        if (IsConstantDeclaration) {
+          env.CreateImmutableBinding(dn, true);
+        } else {
+          env.CreateMutableBinding(dn, false);
+        }
+      }
+
+      if (d.type === "FunctionDeclaration") {
+        const [fn] = (0, _traverse.collectBoundNames)(d);
+        const fo = InstantiateFunctionObject(d, env);
+        env.InitializeBinding(fn, fo);
+      }
+    }
+  } // Function declarations and expressions.
+  // https://tc39.es/ecma262/#sec-evaluatecall
+
+
+  function EvaluateCall(func, ref, args, callee) {
+    let thisValue;
+
+    if (ref instanceof _ExecutionContext.ReferenceRecord) {
+      if ((0, _contextFree.IsPropertyReference)(ref)) {
+        thisValue = ref.Base;
+      }
+    }
+
+    const argList = ArgumentListEvaluation(args);
+
+    if (typeof func !== "function") {
+      const funcName = codeSource.substring(callee.start, callee.end);
+      throw new TypeError(`${funcName} is not a function`);
+    }
+
+    const result = func.apply(thisValue, argList);
+    (0, _sanitize.sanitize)(result);
+    return (0, _ExecutionContext.NormalCompletion)(result);
+  } // https://tc39.es/ecma262/#sec-evaluatenew
+
+
+  function EvaluateNew(constructExpr, args) {
+    const ref = Evaluate(constructExpr);
+    const constructor = (0, _contextFree.GetValue)(ref);
+    const argList = ArgumentListEvaluation(args);
+
+    if (typeof constructor !== "function" || constructor[_ExecutionContext.IsConstructor] === false) {
+      const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
+      throw new TypeError(`${constructorName} is not a constructor`);
+    }
+
+    if (!(0, _sanitize.isAllowedConstructor)(constructor)) {
+      const constructorName = codeSource.substring(constructExpr.start, constructExpr.end);
+      throw new TypeError(`${constructorName} is not an allowed constructor`);
+    }
+
+    return (0, _ExecutionContext.NormalCompletion)(new constructor(...argList));
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
+
+
+  function ArgumentListEvaluation(args) {
+    const array = [];
+
+    if (Array.isArray(args)) {
+      for (const arg of args) {
+        if (arg.type === "SpreadElement") {
+          const spreadValues = (0, _contextFree.GetValue)(Evaluate(arg.argument));
+          array.push(...spreadValues);
+        } else {
+          array.push((0, _contextFree.GetValue)(Evaluate(arg)));
+        }
+      }
+    } else {
+      array.push(GetTemplateObject(args));
+
+      for (const expr of args.expressions) {
+        array.push((0, _contextFree.GetValue)(Evaluate(expr)));
+      }
+    }
+
+    return array;
+  } // https://tc39.es/ecma262/#sec-ecmascript-function-objects-call-thisargument-argumentslist
+
+
+  function CallFunction(closure, args) {
+    PrepareForOrdinaryCall(closure);
+    const result = OrdinaryCallEvaluateBody(closure, args);
+    executionContextStack.pop();
+
+    if (result.Type === "return") {
+      return result.Value;
+    }
+
+    return undefined;
+  } // https://tc39.es/ecma262/#sec-prepareforordinarycall
+
+
+  function PrepareForOrdinaryCall(F) {
+    const calleeContext = new _ExecutionContext.ExecutionContext();
+    calleeContext.Function = F;
+    const localEnv = new _ExecutionContext.FunctionEnvironment(F[_ExecutionContext.Environment]);
+    calleeContext.VariableEnvironment = localEnv;
+    calleeContext.LexicalEnvironment = localEnv;
+    executionContextStack.push(calleeContext);
+    return calleeContext;
+  } // https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
+
+
+  function OrdinaryCallEvaluateBody(F, args) {
+    return EvaluateFunctionBody(F[_ExecutionContext.ECMAScriptCode], F, args);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody
+
+
+  function EvaluateFunctionBody(body, F, args) {
+    FunctionDeclarationInstantiation(F, args);
+
+    if (Array.isArray(body)) {
+      return EvaluateStatementList(body);
+    }
+
+    return new _ExecutionContext.CompletionRecord("return", (0, _contextFree.GetValue)(Evaluate(body)));
+  } // https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
+
+
+  function EvaluateStatementList(statements) {
+    let result = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+
+    for (const stmt of statements) {
+      const s = Evaluate(stmt);
+
+      if (s.Type !== "normal") {
+        return s;
+      }
+
+      result = (0, _contextFree.UpdateEmpty)(result, s.Value);
+    }
+
+    return result;
+  } // https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
+
+
+  function FunctionDeclarationInstantiation(func, args) {
+    const calleeContext = getRunningContext();
+    const code = func[_ExecutionContext.ECMAScriptCode];
+    const formals = func[_ExecutionContext.FormalParameters];
+    const parameterNames = (0, _traverse.collectBoundNames)(formals);
+    const hasParameterExpressions = (0, _traverse.containsExpression)(formals);
+    const varDeclarations = (0, _traverse.collectScopedDeclarations)(code, {
+      var: true,
+      topLevel: true
+    });
+    const varNames = (0, _traverse.collectBoundNames)(varDeclarations); // `functionNames` ∈ `varNames`
+    // `functionsToInitialize` ≈ `functionNames`
+
+    const functionNames = [];
+    const functionsToInitialize = [];
+
+    for (let i = varDeclarations.length - 1; i >= 0; i--) {
+      const d = varDeclarations[i];
+
+      if (d.type === "FunctionDeclaration") {
+        ThrowIfFunctionIsInvalid(d);
+        const [fn] = (0, _traverse.collectBoundNames)(d);
+
+        if (!functionNames.includes(fn)) {
+          functionNames.unshift(fn);
+          functionsToInitialize.unshift(d);
+        }
+      } else if (rules !== null && rules !== void 0 && rules.noVar) {
+        throw new SyntaxError("Var declaration is not recommended, use `let` or `const` instead");
+      }
+    }
+
+    const env = calleeContext.LexicalEnvironment;
+
+    for (const paramName of parameterNames) {
+      // In strict mode, it's guaranteed no duplicate params exist.
+      env.CreateMutableBinding(paramName, false);
+    }
+
+    const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(args);
+    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.
+      for (const n of varNames) {
+        if (!parameterNames.includes(n)) {
+          env.CreateMutableBinding(n, false);
+          env.InitializeBinding(n, undefined);
+        }
+      }
+
+      varEnv = env;
+    } else {
+      // NOTE: A separate Environment Record is needed to ensure that closures
+      // created by expressions in the formal parameter list do not have
+      // visibility of declarations in the function body.
+      varEnv = new _ExecutionContext.DeclarativeEnvironment(env);
+      calleeContext.VariableEnvironment = varEnv; // `varNames` are unique.
+
+      for (const n of varNames) {
+        varEnv.CreateMutableBinding(n, false);
+        let initialValue;
+
+        if (parameterNames.includes(n) && !functionNames.includes(n)) {
+          initialValue = env.GetBindingValue(n, false);
+        }
+
+        varEnv.InitializeBinding(n, initialValue); // NOTE: A var with the same name as a formal parameter initially has
+        // the same value as the corresponding initialized parameter.
+      }
+    }
+
+    const lexEnv = varEnv;
+    calleeContext.LexicalEnvironment = lexEnv;
+    const lexDeclarations = (0, _traverse.collectScopedDeclarations)(code, {
+      var: false,
+      topLevel: true
+    });
+
+    for (const d of lexDeclarations) {
+      for (const dn of (0, _traverse.collectBoundNames)(d)) {
+        // Only lexical VariableDeclaration here in top-level.
+        if (d.kind === "const") {
+          lexEnv.CreateImmutableBinding(dn, true);
+        } else {
+          lexEnv.CreateMutableBinding(dn, false);
+        }
+      }
+    }
+
+    for (const f of functionsToInitialize) {
+      const [fn] = (0, _traverse.collectBoundNames)(f);
+      const fo = InstantiateFunctionObject(f, lexEnv);
+      varEnv.SetMutableBinding(fn, fo, false);
+    }
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatefunctionobject
+
+
+  function InstantiateFunctionObject(func, scope) {
+    return OrdinaryFunctionCreate(func.params, func.body, scope, true);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
+
+
+  function InstantiateOrdinaryFunctionExpression(functionExpression) {
+    const scope = getRunningContext().LexicalEnvironment;
+
+    if (functionExpression.id) {
+      const name = functionExpression.id.name;
+      const funcEnv = new _ExecutionContext.DeclarativeEnvironment(scope);
+      funcEnv.CreateImmutableBinding(name, false);
+      const closure = OrdinaryFunctionCreate(functionExpression.params, functionExpression.body, funcEnv, true);
+      funcEnv.InitializeBinding(name, closure);
+      return closure;
+    } else {
+      const closure = OrdinaryFunctionCreate(functionExpression.params, functionExpression.body, scope, true);
+      return closure;
+    }
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression
+
+
+  function InstantiateArrowFunctionExpression(arrowFunction) {
+    const scope = getRunningContext().LexicalEnvironment;
+    const closure = OrdinaryFunctionCreate(arrowFunction.params, arrowFunction.body, scope, false);
+    return closure;
+  } // https://tc39.es/ecma262/#sec-ordinaryfunctioncreate
+
+
+  function OrdinaryFunctionCreate(parameterList, body, scope, isConstructor) {
+    const F = function () {
+      // eslint-disable-next-line prefer-rest-params
+      return CallFunction(F, arguments);
+    };
+
+    Object.defineProperties(F, {
+      [_ExecutionContext.FormalParameters]: {
+        enumerable: false,
+        writable: false,
+        value: parameterList
+      },
+      [_ExecutionContext.ECMAScriptCode]: {
+        enumerable: false,
+        writable: false,
+        value: body.type === "BlockStatement" ? body.body : body
+      },
+      [_ExecutionContext.Environment]: {
+        enumerable: false,
+        writable: false,
+        value: scope
+      },
+      [_ExecutionContext.IsConstructor]: {
+        enumerable: false,
+        writable: false,
+        value: isConstructor
+      }
+    });
+    return F;
+  } // Patterns initialization.
+  // https://tc39.es/ecma262/#sec-runtime-semantics-bindinginitialization
+
+
+  function BindingInitialization(node, value, environment) {
+    switch (node.type) {
+      case "Identifier":
+        return InitializeBoundName(node.name, value, environment);
+
+      case "ObjectPattern":
+        (0, _contextFree.RequireObjectCoercible)(value);
+        return PropertyBindingInitialization(node.properties, value, environment);
+
+      case "ArrayPattern":
+        {
+          const iteratorRecord = (0, _contextFree.CreateListIteratorRecord)(value);
+          return IteratorBindingInitialization(node.elements, iteratorRecord, environment);
+        }
+    }
+  } // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-propertybindinginitialization
+
+
+  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);
+        excludedNames.add(prop.key.name);
+      } else {
+        const P = EvaluateComputedPropertyName(prop.key);
+        KeyedBindingInitialization(prop.value, value, environment, P);
+        excludedNames.add(P);
+      }
+    }
+
+    return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+  } // https://tc39.es/ecma262/#prod-ComputedPropertyName
+
+
+  function EvaluateComputedPropertyName(node) {
+    const propName = (0, _contextFree.GetValue)(Evaluate(node));
+    return (0, _contextFree.ToPropertyKey)(propName);
+  } // https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-restbindinginitialization
+
+
+  function RestBindingInitialization(restProperty, value, environment, excludedNames) {
+    const lhs = ResolveBinding(restProperty.argument.name, environment);
+    const restObj = (0, _contextFree.CopyDataProperties)({}, value, excludedNames);
+
+    if (!environment) {
+      return (0, _contextFree.PutValue)(lhs, restObj);
+    }
+
+    return (0, _contextFree.InitializeReferencedBinding)(lhs, restObj);
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-iteratorbindinginitialization
+
+
+  function IteratorBindingInitialization(elements, iteratorRecord, environment) {
+    if (elements.length === 0) {
+      return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+    }
+
+    let result;
+
+    for (const node of elements) {
+      if (!node) {
+        // Elision element.
+        iteratorRecord.next();
+        result = (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+      } else if (node.type === "RestElement") {
+        // Rest element.
+        if (node.argument.type === "Identifier") {
+          const lhs = ResolveBinding(node.argument.name, environment);
+          const A = [];
+          let n = 0; // eslint-disable-next-line no-constant-condition
+
+          while (true) {
+            const {
+              done,
+              value
+            } = iteratorRecord.next();
+
+            if (done) {
+              result = environment ? (0, _contextFree.InitializeReferencedBinding)(lhs, A) : (0, _contextFree.PutValue)(lhs, A);
+              break;
+            }
+
+            A[n] = value;
+            n++;
+          }
+        } else {
+          const A = [];
+          let n = 0; // eslint-disable-next-line no-constant-condition
+
+          while (true) {
+            const {
+              done,
+              value
+            } = iteratorRecord.next();
+
+            if (done) {
+              result = BindingInitialization(node.argument, A, environment);
+              break;
+            }
+
+            A[n] = value;
+            n++;
+          }
+        }
+      } else {
+        // Normal element.
+        const bindingElement = node.type === "AssignmentPattern" ? node.left : node;
+
+        switch (bindingElement.type) {
+          case "ObjectPattern":
+          case "ArrayPattern":
+            {
+              let v;
+              const {
+                done,
+                value
+              } = iteratorRecord.next();
+
+              if (!done) {
+                v = value;
+              }
+
+              if (node.type === "AssignmentPattern" && v === undefined) {
+                const defaultValue = Evaluate(node.right);
+                v = (0, _contextFree.GetValue)(defaultValue);
+              }
+
+              result = BindingInitialization(bindingElement, v, environment);
+              break;
+            }
+
+          case "Identifier":
+            {
+              const bindingId = bindingElement.name;
+              const lhs = ResolveBinding(bindingId, environment);
+              let v;
+              const {
+                done,
+                value
+              } = iteratorRecord.next();
+
+              if (!done) {
+                v = value;
+              }
+
+              if (node.type === "AssignmentPattern" && v === undefined) {
+                // IsAnonymousFunctionDefinition(Initializer)
+                const defaultValue = Evaluate(node.right);
+                v = (0, _contextFree.GetValue)(defaultValue);
+              }
+
+              result = environment ? (0, _contextFree.InitializeReferencedBinding)(lhs, v) : (0, _contextFree.PutValue)(lhs, v);
+              break;
+            }
+        }
+      }
+    }
+
+    return result;
+  } // https://tc39.es/ecma262/#sec-runtime-semantics-keyedbindinginitialization
+
+
+  function KeyedBindingInitialization(node, value, environment, propertyName) {
+    const isIdentifier = node.type === "Identifier" || node.type === "AssignmentPattern" && node.left.type === "Identifier";
+
+    if (isIdentifier) {
+      const bindingId = node.type === "Identifier" ? node.name : node.left.name;
+      const lhs = ResolveBinding(bindingId, environment);
+      let v = (0, _contextFree.GetV)(value, propertyName);
+
+      if (node.type === "AssignmentPattern" && v === undefined) {
+        // If IsAnonymousFunctionDefinition(Initializer)
+        const defaultValue = Evaluate(node.right);
+        v = (0, _contextFree.GetValue)(defaultValue);
+      }
+
+      if (!environment) {
+        return (0, _contextFree.PutValue)(lhs, v);
+      }
+
+      return (0, _contextFree.InitializeReferencedBinding)(lhs, v);
+    }
+
+    let v = (0, _contextFree.GetV)(value, propertyName);
+
+    if (node.type === "AssignmentPattern" && v === undefined) {
+      const defaultValue = Evaluate(node.right);
+      v = (0, _contextFree.GetValue)(defaultValue);
+    }
+
+    return BindingInitialization(node.type === "AssignmentPattern" ? node.left : node, v, environment);
+  } // https://tc39.es/ecma262/#sec-initializeboundname
+
+
+  function InitializeBoundName(name, value, environment) {
+    // Assert: environment is always present.
+    environment.InitializeBinding(name, value);
+    return (0, _ExecutionContext.NormalCompletion)(_ExecutionContext.Empty);
+  }
+
+  function ThrowIfFunctionIsInvalid(func) {
+    if (func.async || func.generator) {
+      throw new SyntaxError(`${func.async ? "Async" : "Generator"} function is not allowed`);
+    }
+
+    if (expressionOnly && !func.expression) {
+      throw new SyntaxError("Only an `Expression` is allowed in `ArrowFunctionExpression`'s body");
+    }
+  }
+
+  if (expressionOnly) {
+    return (0, _contextFree.GetValue)(Evaluate(rootAst));
+  }
+
+  ThrowIfFunctionIsInvalid(rootAst);
+  const [fn] = (0, _traverse.collectBoundNames)(rootAst); // Create an immutable binding for the root function.
+
+  rootEnv.CreateImmutableBinding(fn, true);
+  const fo = InstantiateFunctionObject(rootAst, rootEnv);
+  rootEnv.InitializeBinding(fn, fo);
+  return fo;
+}
+//# sourceMappingURL=cook.js.map