@next-core/cook 1.0.1

package/dist/esm/cook.js

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