@builder.io/sdk-solid 0.4.5 → 0.5.1

package/src/functions/evaluate/interpreter.js

@@ -0,0 +1,2801 @@
+/**
+ * @license
+ * Copyright 2013 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var Interpreter = function (code, opt_initFunc) {
+  if (typeof code === "string") {
+    code = this.parse_(code, "code");
+  }
+  var nodeConstructor = code.constructor;
+  this.newNode = function () {
+    return new nodeConstructor({
+      options: {}
+    });
+  };
+  var ast = this.newNode();
+  for (var prop in code) {
+    ast[prop] = prop === "body" ? code[prop].slice() : code[prop];
+  }
+  this.ast = ast;
+  this.initFunc_ = opt_initFunc;
+  this.paused_ = false;
+  this.polyfills_ = [];
+  this.functionCounter_ = 0;
+  this.stepFunctions_ = Object.create(null);
+  var stepMatch = /^step([A-Z]\w*)$/;
+  var m;
+  for (var methodName in this) {
+    if (typeof this[methodName] === "function" && (m = methodName.match(stepMatch))) {
+      this.stepFunctions_[m[1]] = this[methodName].bind(this);
+    }
+  }
+  this.globalScope = this.createScope(this.ast, null);
+  this.globalObject = this.globalScope.object;
+  this.ast = this.parse_(this.polyfills_.join("\n"), "polyfills");
+  this.polyfills_ = void 0;
+  Interpreter.stripLocations_(this.ast, void 0, void 0);
+  var state = new Interpreter.State(this.ast, this.globalScope);
+  state.done = false;
+  this.stateStack = [state];
+  this.run();
+  this.value = void 0;
+  this.ast = ast;
+  state = new Interpreter.State(this.ast, this.globalScope);
+  state.done = false;
+  this.stateStack.length = 0;
+  this.stateStack[0] = state;
+};
+Interpreter.Completion = {
+  NORMAL: 0,
+  BREAK: 1,
+  CONTINUE: 2,
+  RETURN: 3,
+  THROW: 4
+};
+Interpreter.PARSE_OPTIONS = {
+  locations: true,
+  ecmaVersion: 5
+};
+Interpreter.READONLY_DESCRIPTOR = {
+  configurable: true,
+  enumerable: true,
+  writable: false
+};
+Interpreter.NONENUMERABLE_DESCRIPTOR = {
+  configurable: true,
+  enumerable: false,
+  writable: true
+};
+Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR = {
+  configurable: true,
+  enumerable: false,
+  writable: false
+};
+Interpreter.NONCONFIGURABLE_READONLY_NONENUMERABLE_DESCRIPTOR = {
+  configurable: false,
+  enumerable: false,
+  writable: false
+};
+Interpreter.VARIABLE_DESCRIPTOR = {
+  configurable: false,
+  enumerable: true,
+  writable: true
+};
+Interpreter.STEP_ERROR = {
+  STEP_ERROR: true
+};
+Interpreter.SCOPE_REFERENCE = {
+  SCOPE_REFERENCE: true
+};
+Interpreter.VALUE_IN_DESCRIPTOR = {
+  VALUE_IN_DESCRIPTOR: true
+};
+Interpreter.REGEXP_TIMEOUT = {
+  REGEXP_TIMEOUT: true
+};
+Interpreter.toStringCycles_ = [];
+Interpreter.vm = null;
+Interpreter.currentInterpreter_ = null;
+Interpreter.nativeGlobal = typeof globalThis === "undefined" ? void 0 : globalThis;
+Interpreter.WORKER_CODE = ["onmessage = function(e) {", "var result;", "var data = e.data;", "switch (data[0]) {", "case 'split':", "result = data[1].split(data[2], data[3]);", "break;", "case 'match':", "result = data[1].match(data[2]);", "break;", "case 'search':", "result = data[1].search(data[2]);", "break;", "case 'replace':", "result = data[1].replace(data[2], data[3]);", "break;", "case 'exec':", "var regexp = data[1];", "regexp.lastIndex = data[2];", "result = [regexp.exec(data[3]), data[1].lastIndex];", "break;", "default:", "throw Error('Unknown RegExp operation: ' + data[0]);", "}", "postMessage(result);", "close();", "};"];
+Interpreter.legalArrayLength = function (x) {
+  var n = x >>> 0;
+  return n === Number(x) ? n : NaN;
+};
+Interpreter.legalArrayIndex = function (x) {
+  var n = x >>> 0;
+  return String(n) === String(x) && n !== 4294967295 ? n : NaN;
+};
+Interpreter.stripLocations_ = function (node, start, end) {
+  if (start) {
+    node.start = start;
+  } else {
+    delete node.start;
+  }
+  if (end) {
+    node.end = end;
+  } else {
+    delete node.end;
+  }
+  for (var name in node) {
+    if (name !== "loc" && node.hasOwnProperty(name)) {
+      var prop = node[name];
+      if (prop && typeof prop === "object") {
+        Interpreter.stripLocations_(prop, start, end);
+      }
+    }
+  }
+};
+Interpreter.prototype["REGEXP_MODE"] = 2;
+Interpreter.prototype["REGEXP_THREAD_TIMEOUT"] = 1e3;
+Interpreter.prototype["POLYFILL_TIMEOUT"] = 1e3;
+Interpreter.prototype.getterStep_ = false;
+Interpreter.prototype.setterStep_ = false;
+Interpreter.prototype.appendCodeNumber_ = 0;
+Interpreter.prototype.parse_ = function (code, sourceFile) {
+  var options = {};
+  for (var name in Interpreter.PARSE_OPTIONS) {
+    options[name] = Interpreter.PARSE_OPTIONS[name];
+  }
+  options.sourceFile = sourceFile;
+  return Interpreter.nativeGlobal.acornParse(code, options);
+};
+Interpreter.prototype.appendCode = function (code) {
+  var state = this.stateStack[0];
+  if (!state || state.node.type !== "Program") {
+    throw Error("Expecting original AST to start with a Program node");
+  }
+  if (typeof code === "string") {
+    code = this.parse_(code, "appendCode" + this.appendCodeNumber_++);
+  }
+  if (!code || code.type !== "Program") {
+    throw Error("Expecting new AST to start with a Program node");
+  }
+  this.populateScope_(code, state.scope);
+  Array.prototype.push.apply(state.node.body, code.body);
+  state.node.body.variableCache_ = null;
+  state.done = false;
+};
+Interpreter.prototype.step = function () {
+  var stack = this.stateStack;
+  var endTime;
+  do {
+    var state = stack[stack.length - 1];
+    if (!state) {
+      return false;
+    }
+    var node = state.node,
+      type = node.type;
+    if (type === "Program" && state.done) {
+      return false;
+    } else if (this.paused_) {
+      return true;
+    }
+    var oldInterpreterValue = Interpreter.currentInterpreter_;
+    Interpreter.currentInterpreter_ = this;
+    try {
+      var nextState = this.stepFunctions_[type](stack, state, node);
+    } catch (e) {
+      if (e !== Interpreter.STEP_ERROR) {
+        if (this.value !== e) {
+          this.value = void 0;
+        }
+        throw e;
+      }
+    } finally {
+      Interpreter.currentInterpreter_ = oldInterpreterValue;
+    }
+    if (nextState) {
+      stack.push(nextState);
+    }
+    if (this.getterStep_) {
+      this.value = void 0;
+      throw Error("Getter not supported in this context");
+    }
+    if (this.setterStep_) {
+      this.value = void 0;
+      throw Error("Setter not supported in this context");
+    }
+    if (!endTime && !node.end) {
+      endTime = Date.now() + this["POLYFILL_TIMEOUT"];
+    }
+  } while (!node.end && endTime > Date.now());
+  return true;
+};
+Interpreter.prototype.run = function () {
+  while (!this.paused_ && this.step()) {}
+  return this.paused_;
+};
+Interpreter.prototype.initGlobal = function (globalObject) {
+  this.setProperty(globalObject, "NaN", NaN, Interpreter.NONCONFIGURABLE_READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "Infinity", Infinity, Interpreter.NONCONFIGURABLE_READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "undefined", void 0, Interpreter.NONCONFIGURABLE_READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "window", globalObject, Interpreter.READONLY_DESCRIPTOR);
+  this.setProperty(globalObject, "this", globalObject, Interpreter.NONCONFIGURABLE_READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "self", globalObject);
+  this.OBJECT_PROTO = new Interpreter.Object(null);
+  this.FUNCTION_PROTO = new Interpreter.Object(this.OBJECT_PROTO);
+  this.initFunction(globalObject);
+  this.initObject(globalObject);
+  globalObject.proto = this.OBJECT_PROTO;
+  this.setProperty(globalObject, "constructor", this.OBJECT, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.initArray(globalObject);
+  this.initString(globalObject);
+  this.initBoolean(globalObject);
+  this.initNumber(globalObject);
+  this.initDate(globalObject);
+  this.initRegExp(globalObject);
+  this.initError(globalObject);
+  this.initMath(globalObject);
+  this.initJSON(globalObject);
+  var thisInterpreter = this;
+  var func = this.createNativeFunction(function (_x) {
+    throw EvalError("Can't happen");
+  }, false);
+  func.eval = true;
+  this.setProperty(globalObject, "eval", func, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "parseInt", this.createNativeFunction(parseInt, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "parseFloat", this.createNativeFunction(parseFloat, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "isNaN", this.createNativeFunction(isNaN, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "isFinite", this.createNativeFunction(isFinite, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var strFunctions = [[escape, "escape"], [unescape, "unescape"], [decodeURI, "decodeURI"], [decodeURIComponent, "decodeURIComponent"], [encodeURI, "encodeURI"], [encodeURIComponent, "encodeURIComponent"]];
+  for (var i = 0; i < strFunctions.length; i++) {
+    var wrapper = function (nativeFunc) {
+      return function (str) {
+        try {
+          return nativeFunc(str);
+        } catch (e) {
+          thisInterpreter.throwException(thisInterpreter.URI_ERROR, e.message);
+        }
+      };
+    }(strFunctions[i][0]);
+    this.setProperty(globalObject, strFunctions[i][1], this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  }
+  this["OBJECT"] = this.OBJECT;
+  this["OBJECT_PROTO"] = this.OBJECT_PROTO;
+  this["FUNCTION"] = this.FUNCTION;
+  this["FUNCTION_PROTO"] = this.FUNCTION_PROTO;
+  this["ARRAY"] = this.ARRAY;
+  this["ARRAY_PROTO"] = this.ARRAY_PROTO;
+  this["REGEXP"] = this.REGEXP;
+  this["REGEXP_PROTO"] = this.REGEXP_PROTO;
+  this["DATE"] = this.DATE;
+  this["DATE_PROTO"] = this.DATE_PROTO;
+  if (this.initFunc_) {
+    this.initFunc_(this, globalObject);
+  }
+};
+Interpreter.prototype.functionCodeNumber_ = 0;
+Interpreter.prototype.initFunction = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  var identifierRegexp = /^[A-Za-z_$][\w$]*$/;
+  wrapper = function Function2(var_args) {
+    if (arguments.length) {
+      var code = String(arguments[arguments.length - 1]);
+    } else {
+      var code = "";
+    }
+    var argsStr = Array.prototype.slice.call(arguments, 0, -1).join(",").trim();
+    if (argsStr) {
+      var args = argsStr.split(/\s*,\s*/);
+      for (var i = 0; i < args.length; i++) {
+        var name = args[i];
+        if (!identifierRegexp.test(name)) {
+          thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, "Invalid function argument: " + name);
+        }
+      }
+      argsStr = args.join(", ");
+    }
+    try {
+      var ast = thisInterpreter.parse_("(function(" + argsStr + ") {" + code + "})", "function" + thisInterpreter.functionCodeNumber_++);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, "Invalid code: " + e.message);
+    }
+    if (ast.body.length !== 1) {
+      thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, "Invalid code in function body");
+    }
+    var node = ast.body[0].expression;
+    return thisInterpreter.createFunction(node, thisInterpreter.globalScope, "anonymous");
+  };
+  this.FUNCTION = this.createNativeFunction(wrapper, true);
+  this.setProperty(globalObject, "Function", this.FUNCTION, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.FUNCTION, "prototype", this.FUNCTION_PROTO, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.FUNCTION_PROTO, "constructor", this.FUNCTION, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.FUNCTION_PROTO.nativeFunc = function () {};
+  this.FUNCTION_PROTO.nativeFunc.id = this.functionCounter_++;
+  this.FUNCTION_PROTO.illegalConstructor = true;
+  this.setProperty(this.FUNCTION_PROTO, "length", 0, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.FUNCTION_PROTO.class = "Function";
+  wrapper = function apply(thisArg, args) {
+    var state = thisInterpreter.stateStack[thisInterpreter.stateStack.length - 1];
+    state.func_ = this;
+    state.funcThis_ = thisArg;
+    state.arguments_ = [];
+    if (args !== null && args !== void 0) {
+      if (args instanceof Interpreter.Object) {
+        state.arguments_ = thisInterpreter.arrayPseudoToNative(args);
+      } else {
+        thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "CreateListFromArrayLike called on non-object");
+      }
+    }
+    state.doneExec_ = false;
+  };
+  this.setNativeFunctionPrototype(this.FUNCTION, "apply", wrapper);
+  wrapper = function call(thisArg) {
+    var state = thisInterpreter.stateStack[thisInterpreter.stateStack.length - 1];
+    state.func_ = this;
+    state.funcThis_ = thisArg;
+    state.arguments_ = [];
+    for (var i = 1; i < arguments.length; i++) {
+      state.arguments_.push(arguments[i]);
+    }
+    state.doneExec_ = false;
+  };
+  this.setNativeFunctionPrototype(this.FUNCTION, "call", wrapper);
+  this.polyfills_.push("Object.defineProperty(Function.prototype, 'bind',", "{configurable: true, writable: true, value:", "function bind(oThis) {", "if (typeof this !== 'function') {", "throw TypeError('What is trying to be bound is not callable');", "}", "var aArgs   = Array.prototype.slice.call(arguments, 1),", "fToBind = this,", "fNOP    = function() {},", "fBound  = function() {", "return fToBind.apply(this instanceof fNOP", "? this", ": oThis,", "aArgs.concat(Array.prototype.slice.call(arguments)));", "};", "if (this.prototype) {", "fNOP.prototype = this.prototype;", "}", "fBound.prototype = new fNOP();", "return fBound;", "}", "});", "");
+  wrapper = function toString() {
+    return String(this);
+  };
+  this.setNativeFunctionPrototype(this.FUNCTION, "toString", wrapper);
+  this.setProperty(this.FUNCTION, "toString", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function valueOf() {
+    return this.valueOf();
+  };
+  this.setNativeFunctionPrototype(this.FUNCTION, "valueOf", wrapper);
+  this.setProperty(this.FUNCTION, "valueOf", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+};
+Interpreter.prototype.initObject = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function Object2(value) {
+    if (value === void 0 || value === null) {
+      if (thisInterpreter.calledWithNew()) {
+        return this;
+      } else {
+        return thisInterpreter.createObjectProto(thisInterpreter.OBJECT_PROTO);
+      }
+    }
+    if (!(value instanceof Interpreter.Object)) {
+      var box = thisInterpreter.createObjectProto(thisInterpreter.getPrototype(value));
+      box.data = value;
+      return box;
+    }
+    return value;
+  };
+  this.OBJECT = this.createNativeFunction(wrapper, true);
+  this.setProperty(this.OBJECT, "prototype", this.OBJECT_PROTO, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.OBJECT_PROTO, "constructor", this.OBJECT, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(globalObject, "Object", this.OBJECT, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var throwIfNullUndefined = function (value) {
+    if (value === void 0 || value === null) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Cannot convert '" + value + "' to object");
+    }
+  };
+  wrapper = function getOwnPropertyNames(obj) {
+    throwIfNullUndefined(obj);
+    var props = obj instanceof Interpreter.Object ? obj.properties : obj;
+    return thisInterpreter.arrayNativeToPseudo(Object.getOwnPropertyNames(props));
+  };
+  this.setProperty(this.OBJECT, "getOwnPropertyNames", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function keys(obj) {
+    throwIfNullUndefined(obj);
+    if (obj instanceof Interpreter.Object) {
+      obj = obj.properties;
+    }
+    return thisInterpreter.arrayNativeToPseudo(Object.keys(obj));
+  };
+  this.setProperty(this.OBJECT, "keys", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function create_(proto) {
+    if (proto === null) {
+      return thisInterpreter.createObjectProto(null);
+    }
+    if (!(proto instanceof Interpreter.Object)) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Object prototype may only be an Object or null, not " + proto);
+    }
+    return thisInterpreter.createObjectProto(proto);
+  };
+  this.setProperty(this.OBJECT, "create", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.polyfills_.push("(function() {", "var create_ = Object.create;", "Object.create = function create(proto, props) {", "var obj = create_(proto);", "props && Object.defineProperties(obj, props);", "return obj;", "};", "})();", "");
+  wrapper = function defineProperty(obj, prop, descriptor) {
+    prop = String(prop);
+    if (!(obj instanceof Interpreter.Object)) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Object.defineProperty called on non-object: " + obj);
+    }
+    if (!(descriptor instanceof Interpreter.Object)) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Property description must be an object");
+    }
+    if (obj.preventExtensions && !(prop in obj.properties)) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Can't define property '" + prop + "', object is not extensible");
+    }
+    thisInterpreter.setProperty(obj, prop, Interpreter.VALUE_IN_DESCRIPTOR, descriptor.properties);
+    return obj;
+  };
+  this.setProperty(this.OBJECT, "defineProperty", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.polyfills_.push("(function() {", "var defineProperty_ = Object.defineProperty;", "Object.defineProperty = function defineProperty(obj, prop, d1) {", "var d2 = {};", "if ('configurable' in d1) d2.configurable = d1.configurable;", "if ('enumerable' in d1) d2.enumerable = d1.enumerable;", "if ('writable' in d1) d2.writable = d1.writable;", "if ('value' in d1) d2.value = d1.value;", "if ('get' in d1) d2.get = d1.get;", "if ('set' in d1) d2.set = d1.set;", "return defineProperty_(obj, prop, d2);", "};", "})();", "Object.defineProperty(Object, 'defineProperties',", "{configurable: true, writable: true, value:", "function defineProperties(obj, props) {", "var keys = Object.keys(props);", "for (var i = 0; i < keys.length; i++) {", "Object.defineProperty(obj, keys[i], props[keys[i]]);", "}", "return obj;", "}", "});", "");
+  wrapper = function getOwnPropertyDescriptor(obj, prop) {
+    if (!(obj instanceof Interpreter.Object)) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Object.getOwnPropertyDescriptor called on non-object: " + obj);
+    }
+    prop = String(prop);
+    if (!(prop in obj.properties)) {
+      return void 0;
+    }
+    var descriptor = Object.getOwnPropertyDescriptor(obj.properties, prop);
+    var getter = obj.getter[prop];
+    var setter = obj.setter[prop];
+    var pseudoDescriptor = thisInterpreter.createObjectProto(thisInterpreter.OBJECT_PROTO);
+    if (getter || setter) {
+      thisInterpreter.setProperty(pseudoDescriptor, "get", getter);
+      thisInterpreter.setProperty(pseudoDescriptor, "set", setter);
+    } else {
+      thisInterpreter.setProperty(pseudoDescriptor, "value", descriptor["value"]);
+      thisInterpreter.setProperty(pseudoDescriptor, "writable", descriptor["writable"]);
+    }
+    thisInterpreter.setProperty(pseudoDescriptor, "configurable", descriptor["configurable"]);
+    thisInterpreter.setProperty(pseudoDescriptor, "enumerable", descriptor["enumerable"]);
+    return pseudoDescriptor;
+  };
+  this.setProperty(this.OBJECT, "getOwnPropertyDescriptor", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function getPrototypeOf(obj) {
+    throwIfNullUndefined(obj);
+    return thisInterpreter.getPrototype(obj);
+  };
+  this.setProperty(this.OBJECT, "getPrototypeOf", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function isExtensible(obj) {
+    return Boolean(obj) && !obj.preventExtensions;
+  };
+  this.setProperty(this.OBJECT, "isExtensible", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function preventExtensions(obj) {
+    if (obj instanceof Interpreter.Object) {
+      obj.preventExtensions = true;
+    }
+    return obj;
+  };
+  this.setProperty(this.OBJECT, "preventExtensions", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setNativeFunctionPrototype(this.OBJECT, "toString", Interpreter.Object.prototype.toString);
+  this.setNativeFunctionPrototype(this.OBJECT, "toLocaleString", Interpreter.Object.prototype.toString);
+  this.setNativeFunctionPrototype(this.OBJECT, "valueOf", Interpreter.Object.prototype.valueOf);
+  wrapper = function hasOwnProperty(prop) {
+    throwIfNullUndefined(this);
+    if (this instanceof Interpreter.Object) {
+      return String(prop) in this.properties;
+    }
+    return this.hasOwnProperty(prop);
+  };
+  this.setNativeFunctionPrototype(this.OBJECT, "hasOwnProperty", wrapper);
+  wrapper = function propertyIsEnumerable(prop) {
+    throwIfNullUndefined(this);
+    if (this instanceof Interpreter.Object) {
+      return Object.prototype.propertyIsEnumerable.call(this.properties, prop);
+    }
+    return this.propertyIsEnumerable(prop);
+  };
+  this.setNativeFunctionPrototype(this.OBJECT, "propertyIsEnumerable", wrapper);
+  wrapper = function isPrototypeOf(obj) {
+    while (true) {
+      obj = thisInterpreter.getPrototype(obj);
+      if (!obj) {
+        return false;
+      }
+      if (obj === this) {
+        return true;
+      }
+    }
+  };
+  this.setNativeFunctionPrototype(this.OBJECT, "isPrototypeOf", wrapper);
+};
+Interpreter.prototype.initArray = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function Array2(var_args) {
+    if (thisInterpreter.calledWithNew()) {
+      var newArray = this;
+    } else {
+      var newArray = thisInterpreter.createArray();
+    }
+    var first = arguments[0];
+    if (arguments.length === 1 && typeof first === "number") {
+      if (isNaN(Interpreter.legalArrayLength(first))) {
+        thisInterpreter.throwException(thisInterpreter.RANGE_ERROR, "Invalid array length: " + first);
+      }
+      newArray.properties.length = first;
+    } else {
+      for (var i = 0; i < arguments.length; i++) {
+        newArray.properties[i] = arguments[i];
+      }
+      newArray.properties.length = i;
+    }
+    return newArray;
+  };
+  this.ARRAY = this.createNativeFunction(wrapper, true);
+  this.ARRAY_PROTO = this.ARRAY.properties["prototype"];
+  this.setProperty(globalObject, "Array", this.ARRAY, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function isArray(obj) {
+    return obj && obj.class === "Array";
+  };
+  this.setProperty(this.ARRAY, "isArray", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.ARRAY_PROTO, "length", 0, {
+    configurable: false,
+    enumerable: false,
+    writable: true
+  });
+  this.ARRAY_PROTO.class = "Array";
+  this.polyfills_.push("(function() {", "function createArrayMethod_(f) {", "Object.defineProperty(Array.prototype, f.name,", "{configurable: true, writable: true, value: f});", "}", "createArrayMethod_(", "function pop() {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "if (!len || len < 0) {", "o.length = 0;", "return undefined;", "}", "len--;", "var x = o[len];", "delete o[len];", "o.length = len;", "return x;", "}", ");", "createArrayMethod_(", "function push(var_args) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "for (var i = 0; i < arguments.length; i++) {", "o[len] = arguments[i];", "len++;", "}", "o.length = len;", "return len;", "}", ");", "createArrayMethod_(", "function shift() {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "if (!len || len < 0) {", "o.length = 0;", "return undefined;", "}", "var value = o[0];", "for (var i = 0; i < len - 1; i++) {", "if ((i + 1) in o) {", "o[i] = o[i + 1];", "} else {", "delete o[i];", "}", "}", "delete o[i];", "o.length = len - 1;", "return value;", "}", ");", "createArrayMethod_(", "function unshift(var_args) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "if (!len || len < 0) {", "len = 0;", "}", "for (var i = len - 1; i >= 0; i--) {", "if (i in o) {", "o[i + arguments.length] = o[i];", "} else {", "delete o[i + arguments.length];", "}", "}", "for (var i = 0; i < arguments.length; i++) {", "o[i] = arguments[i];", "}", "return (o.length = len + arguments.length);", "}", ");", "createArrayMethod_(", "function reverse() {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "if (!len || len < 2) {", "return o;", "}", "for (var i = 0; i < len / 2 - 0.5; i++) {", "var x = o[i];", "var hasX = i in o;", "if ((len - i - 1) in o) {", "o[i] = o[len - i - 1];", "} else {", "delete o[i];", "}", "if (hasX) {", "o[len - i - 1] = x;", "} else {", "delete o[len - i - 1];", "}", "}", "return o;", "}", ");", "createArrayMethod_(", "function indexOf(searchElement, fromIndex) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var n = fromIndex | 0;", "if (!len || n >= len) {", "return -1;", "}", "var i = Math.max(n >= 0 ? n : len - Math.abs(n), 0);", "while (i < len) {", "if (i in o && o[i] === searchElement) {", "return i;", "}", "i++;", "}", "return -1;", "}", ");", "createArrayMethod_(", "function lastIndexOf(searchElement, fromIndex) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "if (!len) {", "return -1;", "}", "var n = len - 1;", "if (arguments.length > 1) {", "n = fromIndex | 0;", "if (n) {", "n = (n > 0 || -1) * Math.floor(Math.abs(n));", "}", "}", "var i = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n);", "while (i >= 0) {", "if (i in o && o[i] === searchElement) {", "return i;", "}", "i--;", "}", "return -1;", "}", ");", "createArrayMethod_(", "function slice(start, end) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "start |= 0;", "start = (start >= 0) ? start : Math.max(0, len + start);", "if (typeof end !== 'undefined') {", "if (end !== Infinity) {", "end |= 0;", "}", "if (end < 0) {", "end = len + end;", "} else {", "end = Math.min(end, len);", "}", "} else {", "end = len;", "}", "var size = end - start;", "var cloned = new Array(size);", "for (var i = 0; i < size; i++) {", "if ((start + i) in o) {", "cloned[i] = o[start + i];", "}", "}", "return cloned;", "}", ");", "createArrayMethod_(", "function splice(start, deleteCount, var_args) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "start |= 0;", "if (start < 0) {", "start = Math.max(len + start, 0);", "} else {", "start = Math.min(start, len);", "}", "if (arguments.length < 1) {", "deleteCount = len - start;", "} else {", "deleteCount |= 0;", "deleteCount = Math.max(0, Math.min(deleteCount, len - start));", "}", "var removed = [];", "for (var i = start; i < start + deleteCount; i++) {", "if (i in o) {", "removed.push(o[i]);", "} else {", "removed.length++;", "}", "if ((i + deleteCount) in o) {", "o[i] = o[i + deleteCount];", "} else {", "delete o[i];", "}", "}", "for (var i = start + deleteCount; i < len - deleteCount; i++) {", "if ((i + deleteCount) in o) {", "o[i] = o[i + deleteCount];", "} else {", "delete o[i];", "}", "}", "for (var i = len - deleteCount; i < len; i++) {", "delete o[i];", "}", "len -= deleteCount;", "var arl = arguments.length - 2;", "for (var i = len - 1; i >= start; i--) {", "if (i in o) {", "o[i + arl] = o[i];", "} else {", "delete o[i + arl];", "}", "}", "len += arl;", "for (var i = 2; i < arguments.length; i++) {", "o[start + i - 2] = arguments[i];", "}", "o.length = len;", "return removed;", "}", ");", "createArrayMethod_(", "function concat(var_args) {", "if (!this) throw TypeError();", "var o = Object(this);", "var cloned = [];", "for (var i = -1; i < arguments.length; i++) {", "var value = (i === -1) ? o : arguments[i];", "if (Array.isArray(value)) {", "for (var j = 0, l = value.length; j < l; j++) {", "if (j in value) {", "cloned.push(value[j]);", "} else {", "cloned.length++;", "}", "}", "} else {", "cloned.push(value);", "}", "}", "return cloned;", "}", ");", "createArrayMethod_(", "function join(opt_separator) {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var sep = typeof opt_separator === 'undefined' ?", "',' : ('' + opt_separator);", "var str = '';", "for (var i = 0; i < len; i++) {", "if (i && sep) {", "str += sep;", "}", "str += (o[i] === null || o[i] === undefined) ? '' : o[i];", "}", "return str;", "}", ");", "createArrayMethod_(", "function every(callbackfn, thisArg) {", "if (!this || typeof callbackfn !== 'function') throw TypeError();", "var t, k = 0;", "var o = Object(this), len = o.length >>> 0;", "if (arguments.length > 1) t = thisArg;", "while (k < len) {", "if (k in o && !callbackfn.call(t, o[k], k, o)) return false;", "k++;", "}", "return true;", "}", ");", "createArrayMethod_(", "function filter(fun, var_args) {", "if (this === void 0 || this === null || typeof fun !== 'function') throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var res = [];", "var thisArg = arguments.length >= 2 ? arguments[1] : void 0;", "for (var i = 0; i < len; i++) {", "if (i in o) {", "var val = o[i];", "if (fun.call(thisArg, val, i, o)) res.push(val);", "}", "}", "return res;", "}", ");", "createArrayMethod_(", "function forEach(callback, thisArg) {", "if (!this || typeof callback !== 'function') throw TypeError();", "var t, k = 0;", "var o = Object(this), len = o.length >>> 0;", "if (arguments.length > 1) t = thisArg;", "while (k < len) {", "if (k in o) callback.call(t, o[k], k, o);", "k++;", "}", "}", ");", "createArrayMethod_(", "function map(callback, thisArg) {", "if (!this || typeof callback !== 'function') throw TypeError();", "var t, k = 0;", "var o = Object(this), len = o.length >>> 0;", "if (arguments.length > 1) t = thisArg;", "var a = new Array(len);", "while (k < len) {", "if (k in o) a[k] = callback.call(t, o[k], k, o);", "k++;", "}", "return a;", "}", ");", "createArrayMethod_(", "function reduce(callback /*, initialValue*/) {", "if (!this || typeof callback !== 'function') throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var k = 0, value;", "if (arguments.length === 2) {", "value = arguments[1];", "} else {", "while (k < len && !(k in o)) k++;", "if (k >= len) {", "throw TypeError('Reduce of empty array with no initial value');", "}", "value = o[k++];", "}", "for (; k < len; k++) {", "if (k in o) value = callback(value, o[k], k, o);", "}", "return value;", "}", ");", "createArrayMethod_(", "function reduceRight(callback /*, initialValue*/) {", "if (null === this || 'undefined' === typeof this || 'function' !== typeof callback) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var k = len - 1, value;", "if (arguments.length >= 2) {", "value = arguments[1];", "} else {", "while (k >= 0 && !(k in o)) k--;", "if (k < 0) {", "throw TypeError('Reduce of empty array with no initial value');", "}", "value = o[k--];", "}", "for (; k >= 0; k--) {", "if (k in o) value = callback(value, o[k], k, o);", "}", "return value;", "}", ");", "createArrayMethod_(", "function some(fun/*, thisArg*/) {", "if (!this || typeof fun !== 'function') throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var thisArg = arguments.length >= 2 ? arguments[1] : void 0;", "for (var i = 0; i < len; i++) {", "if (i in o && fun.call(thisArg, o[i], i, o)) {", "return true;", "}", "}", "return false;", "}", ");", "createArrayMethod_(", "function sort(opt_comp) {", "if (!this) throw TypeError();", "if (typeof opt_comp !== 'function') {", "opt_comp = undefined;", "}", "for (var i = 0; i < this.length; i++) {", "var changes = 0;", "for (var j = 0; j < this.length - i - 1; j++) {", "if (opt_comp ? (opt_comp(this[j], this[j + 1]) > 0) :", "(String(this[j]) > String(this[j + 1]))) {", "var swap = this[j];", "var hasSwap = j in this;", "if ((j + 1) in this) {", "this[j] = this[j + 1];", "} else {", "delete this[j];", "}", "if (hasSwap) {", "this[j + 1] = swap;", "} else {", "delete this[j + 1];", "}", "changes++;", "}", "}", "if (!changes) break;", "}", "return this;", "}", ");", "createArrayMethod_(", "function toLocaleString() {", "if (!this) throw TypeError();", "var o = Object(this), len = o.length >>> 0;", "var out = [];", "for (var i = 0; i < len; i++) {", "out[i] = (o[i] === null || o[i] === undefined) ? '' : o[i].toLocaleString();", "}", "return out.join(',');", "}", ");", "})();", "");
+};
+Interpreter.prototype.initString = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function String2(value) {
+    value = arguments.length ? Interpreter.nativeGlobal.String(value) : "";
+    if (thisInterpreter.calledWithNew()) {
+      this.data = value;
+      return this;
+    } else {
+      return value;
+    }
+  };
+  this.STRING = this.createNativeFunction(wrapper, true);
+  this.setProperty(globalObject, "String", this.STRING, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.STRING, "fromCharCode", this.createNativeFunction(String.fromCharCode, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var functions = ["charAt", "charCodeAt", "concat", "indexOf", "lastIndexOf", "slice", "substr", "substring", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toUpperCase", "trim"];
+  for (var i = 0; i < functions.length; i++) {
+    this.setNativeFunctionPrototype(this.STRING, functions[i], String.prototype[functions[i]]);
+  }
+  wrapper = function localeCompare(compareString, locales, options) {
+    locales = thisInterpreter.pseudoToNative(locales);
+    options = thisInterpreter.pseudoToNative(options);
+    try {
+      return String(this).localeCompare(compareString, locales, options);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.ERROR, "localeCompare: " + e.message);
+    }
+  };
+  this.setNativeFunctionPrototype(this.STRING, "localeCompare", wrapper);
+  wrapper = function split(separator, limit, callback) {
+    var string = String(this);
+    limit = limit ? Number(limit) : void 0;
+    if (thisInterpreter.isa(separator, thisInterpreter.REGEXP)) {
+      separator = separator.data;
+      thisInterpreter.maybeThrowRegExp(separator, callback);
+      if (thisInterpreter["REGEXP_MODE"] === 2) {
+        if (Interpreter.vm) {
+          var sandbox = {
+            string,
+            separator,
+            limit
+          };
+          var code = "string.split(separator, limit)";
+          var jsList = thisInterpreter.vmCall(code, sandbox, separator, callback);
+          if (jsList !== Interpreter.REGEXP_TIMEOUT) {
+            callback(thisInterpreter.arrayNativeToPseudo(jsList));
+          }
+        } else {
+          var splitWorker = thisInterpreter.createWorker();
+          var pid = thisInterpreter.regExpTimeout(separator, splitWorker, callback);
+          splitWorker.onmessage = function (e) {
+            clearTimeout(pid);
+            callback(thisInterpreter.arrayNativeToPseudo(e.data));
+          };
+          splitWorker.postMessage(["split", string, separator, limit]);
+        }
+        return;
+      }
+    }
+    var jsList = string.split(separator, limit);
+    callback(thisInterpreter.arrayNativeToPseudo(jsList));
+  };
+  this.setAsyncFunctionPrototype(this.STRING, "split", wrapper);
+  wrapper = function match(regexp, callback) {
+    var string = String(this);
+    regexp = thisInterpreter.isa(regexp, thisInterpreter.REGEXP) ? regexp.data : new RegExp(regexp);
+    thisInterpreter.maybeThrowRegExp(regexp, callback);
+    if (thisInterpreter["REGEXP_MODE"] === 2) {
+      if (Interpreter.vm) {
+        var sandbox = {
+          string,
+          regexp
+        };
+        var code = "string.match(regexp)";
+        var m = thisInterpreter.vmCall(code, sandbox, regexp, callback);
+        if (m !== Interpreter.REGEXP_TIMEOUT) {
+          callback(m && thisInterpreter.arrayNativeToPseudo(m));
+        }
+      } else {
+        var matchWorker = thisInterpreter.createWorker();
+        var pid = thisInterpreter.regExpTimeout(regexp, matchWorker, callback);
+        matchWorker.onmessage = function (e) {
+          clearTimeout(pid);
+          callback(e.data && thisInterpreter.arrayNativeToPseudo(e.data));
+        };
+        matchWorker.postMessage(["match", string, regexp]);
+      }
+      return;
+    }
+    var m = string.match(regexp);
+    callback(m && thisInterpreter.arrayNativeToPseudo(m));
+  };
+  this.setAsyncFunctionPrototype(this.STRING, "match", wrapper);
+  wrapper = function search(regexp, callback) {
+    var string = String(this);
+    if (thisInterpreter.isa(regexp, thisInterpreter.REGEXP)) {
+      regexp = regexp.data;
+    } else {
+      regexp = new RegExp(regexp);
+    }
+    thisInterpreter.maybeThrowRegExp(regexp, callback);
+    if (thisInterpreter["REGEXP_MODE"] === 2) {
+      if (Interpreter.vm) {
+        var sandbox = {
+          string,
+          regexp
+        };
+        var code = "string.search(regexp)";
+        var n = thisInterpreter.vmCall(code, sandbox, regexp, callback);
+        if (n !== Interpreter.REGEXP_TIMEOUT) {
+          callback(n);
+        }
+      } else {
+        var searchWorker = thisInterpreter.createWorker();
+        var pid = thisInterpreter.regExpTimeout(regexp, searchWorker, callback);
+        searchWorker.onmessage = function (e) {
+          clearTimeout(pid);
+          callback(e.data);
+        };
+        searchWorker.postMessage(["search", string, regexp]);
+      }
+      return;
+    }
+    callback(string.search(regexp));
+  };
+  this.setAsyncFunctionPrototype(this.STRING, "search", wrapper);
+  wrapper = function replace_(substr, newSubstr, callback) {
+    var string = String(this);
+    newSubstr = String(newSubstr);
+    if (thisInterpreter.isa(substr, thisInterpreter.REGEXP)) {
+      substr = substr.data;
+      thisInterpreter.maybeThrowRegExp(substr, callback);
+      if (thisInterpreter["REGEXP_MODE"] === 2) {
+        if (Interpreter.vm) {
+          var sandbox = {
+            string,
+            substr,
+            newSubstr
+          };
+          var code = "string.replace(substr, newSubstr)";
+          var str = thisInterpreter.vmCall(code, sandbox, substr, callback);
+          if (str !== Interpreter.REGEXP_TIMEOUT) {
+            callback(str);
+          }
+        } else {
+          var replaceWorker = thisInterpreter.createWorker();
+          var pid = thisInterpreter.regExpTimeout(substr, replaceWorker, callback);
+          replaceWorker.onmessage = function (e) {
+            clearTimeout(pid);
+            callback(e.data);
+          };
+          replaceWorker.postMessage(["replace", string, substr, newSubstr]);
+        }
+        return;
+      }
+    }
+    callback(string.replace(substr, newSubstr));
+  };
+  this.setAsyncFunctionPrototype(this.STRING, "replace", wrapper);
+  this.polyfills_.push("(function() {", "var replace_ = String.prototype.replace;", "String.prototype.replace = function replace(substr, newSubstr) {", "if (typeof newSubstr !== 'function') {", "return replace_.call(this, substr, newSubstr);", "}", "var str = this;", "if (substr instanceof RegExp) {", "var subs = [];", "var m = substr.exec(str);", "while (m) {", "m.push(m.index, str);", "var inject = newSubstr.apply(null, m);", "subs.push([m.index, m[0].length, inject]);", "m = substr.global ? substr.exec(str) : null;", "}", "for (var i = subs.length - 1; i >= 0; i--) {", "str = str.substring(0, subs[i][0]) + subs[i][2] + str.substring(subs[i][0] + subs[i][1]);", "}", "} else {", "var i = str.indexOf(substr);", "if (i !== -1) {", "var inject = newSubstr(str.substr(i, substr.length), i, str);", "str = str.substring(0, i) + inject + str.substring(i + substr.length);", "}", "}", "return str;", "};", "})();", "");
+};
+Interpreter.prototype.initBoolean = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function Boolean2(value) {
+    value = Interpreter.nativeGlobal.Boolean(value);
+    if (thisInterpreter.calledWithNew()) {
+      this.data = value;
+      return this;
+    } else {
+      return value;
+    }
+  };
+  this.BOOLEAN = this.createNativeFunction(wrapper, true);
+  this.setProperty(globalObject, "Boolean", this.BOOLEAN, Interpreter.NONENUMERABLE_DESCRIPTOR);
+};
+Interpreter.prototype.initNumber = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function Number2(value) {
+    value = arguments.length ? Interpreter.nativeGlobal.Number(value) : 0;
+    if (thisInterpreter.calledWithNew()) {
+      this.data = value;
+      return this;
+    } else {
+      return value;
+    }
+  };
+  this.NUMBER = this.createNativeFunction(wrapper, true);
+  this.setProperty(globalObject, "Number", this.NUMBER, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var numConsts = ["MAX_VALUE", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY"];
+  for (var i = 0; i < numConsts.length; i++) {
+    this.setProperty(this.NUMBER, numConsts[i], Number[numConsts[i]], Interpreter.NONCONFIGURABLE_READONLY_NONENUMERABLE_DESCRIPTOR);
+  }
+  wrapper = function toExponential(fractionDigits) {
+    try {
+      return Number(this).toExponential(fractionDigits);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.ERROR, e.message);
+    }
+  };
+  this.setNativeFunctionPrototype(this.NUMBER, "toExponential", wrapper);
+  wrapper = function toFixed(digits) {
+    try {
+      return Number(this).toFixed(digits);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.ERROR, e.message);
+    }
+  };
+  this.setNativeFunctionPrototype(this.NUMBER, "toFixed", wrapper);
+  wrapper = function toPrecision(precision) {
+    try {
+      return Number(this).toPrecision(precision);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.ERROR, e.message);
+    }
+  };
+  this.setNativeFunctionPrototype(this.NUMBER, "toPrecision", wrapper);
+  wrapper = function toString(radix) {
+    try {
+      return Number(this).toString(radix);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.ERROR, e.message);
+    }
+  };
+  this.setNativeFunctionPrototype(this.NUMBER, "toString", wrapper);
+  wrapper = function toLocaleString(locales, options) {
+    locales = locales ? thisInterpreter.pseudoToNative(locales) : void 0;
+    options = options ? thisInterpreter.pseudoToNative(options) : void 0;
+    try {
+      return Number(this).toLocaleString(locales, options);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.ERROR, "toLocaleString: " + e.message);
+    }
+  };
+  this.setNativeFunctionPrototype(this.NUMBER, "toLocaleString", wrapper);
+};
+Interpreter.prototype.initDate = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function Date2(_value, var_args) {
+    if (!thisInterpreter.calledWithNew()) {
+      return Interpreter.nativeGlobal.Date();
+    }
+    var args = [null].concat(Array.from(arguments));
+    this.data = new (Function.prototype.bind.apply(Interpreter.nativeGlobal.Date, args))();
+    return this;
+  };
+  this.DATE = this.createNativeFunction(wrapper, true);
+  this.DATE_PROTO = this.DATE.properties["prototype"];
+  this.setProperty(globalObject, "Date", this.DATE, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.DATE, "now", this.createNativeFunction(Date.now, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.DATE, "parse", this.createNativeFunction(Date.parse, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.DATE, "UTC", this.createNativeFunction(Date.UTC, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var functions = ["getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds", "getTime", "getTimezoneOffset", "getUTCDate", "getUTCDay", "getUTCFullYear", "getUTCHours", "getUTCMilliseconds", "getUTCMinutes", "getUTCMonth", "getUTCSeconds", "getYear", "setDate", "setFullYear", "setHours", "setMilliseconds", "setMinutes", "setMonth", "setSeconds", "setTime", "setUTCDate", "setUTCFullYear", "setUTCHours", "setUTCMilliseconds", "setUTCMinutes", "setUTCMonth", "setUTCSeconds", "setYear", "toDateString", "toISOString", "toJSON", "toGMTString", "toLocaleDateString", "toLocaleString", "toLocaleTimeString", "toTimeString", "toUTCString"];
+  for (var i = 0; i < functions.length; i++) {
+    wrapper = function (nativeFunc) {
+      return function (var_args) {
+        var date = this.data;
+        if (!(date instanceof Date)) {
+          thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, nativeFunc + " not called on a Date");
+        }
+        var args = [];
+        for (var i2 = 0; i2 < arguments.length; i2++) {
+          args[i2] = thisInterpreter.pseudoToNative(arguments[i2]);
+        }
+        return date[nativeFunc].apply(date, args);
+      };
+    }(functions[i]);
+    this.setNativeFunctionPrototype(this.DATE, functions[i], wrapper);
+  }
+};
+Interpreter.prototype.initRegExp = function (globalObject) {
+  var thisInterpreter = this;
+  var wrapper;
+  wrapper = function RegExp2(pattern, flags) {
+    if (thisInterpreter.calledWithNew()) {
+      var rgx = this;
+    } else {
+      if (flags === void 0 && thisInterpreter.isa(pattern, thisInterpreter.REGEXP)) {
+        return pattern;
+      }
+      var rgx = thisInterpreter.createObjectProto(thisInterpreter.REGEXP_PROTO);
+    }
+    pattern = pattern === void 0 ? "" : String(pattern);
+    flags = flags ? String(flags) : "";
+    if (!/^[gmi]*$/.test(flags)) {
+      thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, "Invalid regexp flag: " + flags);
+    }
+    try {
+      var nativeRegExp = new Interpreter.nativeGlobal.RegExp(pattern, flags);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, e.message);
+    }
+    thisInterpreter.populateRegExp(rgx, nativeRegExp);
+    return rgx;
+  };
+  this.REGEXP = this.createNativeFunction(wrapper, true);
+  this.REGEXP_PROTO = this.REGEXP.properties["prototype"];
+  this.setProperty(globalObject, "RegExp", this.REGEXP, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.REGEXP.properties["prototype"], "global", void 0, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.REGEXP.properties["prototype"], "ignoreCase", void 0, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.REGEXP.properties["prototype"], "multiline", void 0, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.REGEXP.properties["prototype"], "source", "(?:)", Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.polyfills_.push("Object.defineProperty(RegExp.prototype, 'test',", "{configurable: true, writable: true, value:", "function test(str) {", "return !!this.exec(str);", "}", "});");
+  wrapper = function exec(string, callback) {
+    var regexp = this.data;
+    string = String(string);
+    regexp.lastIndex = Number(thisInterpreter.getProperty(this, "lastIndex"));
+    thisInterpreter.maybeThrowRegExp(regexp, callback);
+    if (thisInterpreter["REGEXP_MODE"] === 2) {
+      if (Interpreter.vm) {
+        var sandbox = {
+          string,
+          regexp
+        };
+        var code = "regexp.exec(string)";
+        var match = thisInterpreter.vmCall(code, sandbox, regexp, callback);
+        if (match !== Interpreter.REGEXP_TIMEOUT) {
+          thisInterpreter.setProperty(this, "lastIndex", regexp.lastIndex);
+          callback(matchToPseudo(match));
+        }
+      } else {
+        var execWorker = thisInterpreter.createWorker();
+        var pid = thisInterpreter.regExpTimeout(regexp, execWorker, callback);
+        var thisPseudoRegExp = this;
+        execWorker.onmessage = function (e) {
+          clearTimeout(pid);
+          thisInterpreter.setProperty(thisPseudoRegExp, "lastIndex", e.data[1]);
+          callback(matchToPseudo(e.data[0]));
+        };
+        execWorker.postMessage(["exec", regexp, regexp.lastIndex, string]);
+      }
+      return;
+    }
+    var match = regexp.exec(string);
+    thisInterpreter.setProperty(this, "lastIndex", regexp.lastIndex);
+    callback(matchToPseudo(match));
+    function matchToPseudo(match2) {
+      if (match2) {
+        var result = thisInterpreter.arrayNativeToPseudo(match2);
+        thisInterpreter.setProperty(result, "index", match2.index);
+        thisInterpreter.setProperty(result, "input", match2.input);
+        return result;
+      }
+      return null;
+    }
+  };
+  this.setAsyncFunctionPrototype(this.REGEXP, "exec", wrapper);
+};
+Interpreter.prototype.initError = function (globalObject) {
+  var thisInterpreter = this;
+  this.ERROR = this.createNativeFunction(function Error2(opt_message) {
+    if (thisInterpreter.calledWithNew()) {
+      var newError = this;
+    } else {
+      var newError = thisInterpreter.createObject(thisInterpreter.ERROR);
+    }
+    thisInterpreter.populateError(newError, opt_message);
+    return newError;
+  }, true);
+  this.setProperty(globalObject, "Error", this.ERROR, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.ERROR.properties["prototype"], "message", "", Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.ERROR.properties["prototype"], "name", "Error", Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var createErrorSubclass = function (name) {
+    var constructor = thisInterpreter.createNativeFunction(function (opt_message) {
+      if (thisInterpreter.calledWithNew()) {
+        var newError = this;
+      } else {
+        var newError = thisInterpreter.createObject(constructor);
+      }
+      thisInterpreter.populateError(newError, opt_message);
+      return newError;
+    }, true);
+    thisInterpreter.setProperty(constructor, "prototype", thisInterpreter.createObject(thisInterpreter.ERROR), Interpreter.NONENUMERABLE_DESCRIPTOR);
+    thisInterpreter.setProperty(constructor.properties["prototype"], "name", name, Interpreter.NONENUMERABLE_DESCRIPTOR);
+    thisInterpreter.setProperty(globalObject, name, constructor, Interpreter.NONENUMERABLE_DESCRIPTOR);
+    return constructor;
+  };
+  this.EVAL_ERROR = createErrorSubclass("EvalError");
+  this.RANGE_ERROR = createErrorSubclass("RangeError");
+  this.REFERENCE_ERROR = createErrorSubclass("ReferenceError");
+  this.SYNTAX_ERROR = createErrorSubclass("SyntaxError");
+  this.TYPE_ERROR = createErrorSubclass("TypeError");
+  this.URI_ERROR = createErrorSubclass("URIError");
+};
+Interpreter.prototype.initMath = function (globalObject) {
+  var myMath = this.createObjectProto(this.OBJECT_PROTO);
+  this.setProperty(globalObject, "Math", myMath, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  var mathConsts = ["E", "LN2", "LN10", "LOG2E", "LOG10E", "PI", "SQRT1_2", "SQRT2"];
+  for (var i = 0; i < mathConsts.length; i++) {
+    this.setProperty(myMath, mathConsts[i], Math[mathConsts[i]], Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  }
+  var numFunctions = ["abs", "acos", "asin", "atan", "atan2", "ceil", "cos", "exp", "floor", "log", "max", "min", "pow", "random", "round", "sin", "sqrt", "tan"];
+  for (var i = 0; i < numFunctions.length; i++) {
+    this.setProperty(myMath, numFunctions[i], this.createNativeFunction(Math[numFunctions[i]], false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  }
+};
+Interpreter.prototype.initJSON = function (globalObject) {
+  var wrapper;
+  var thisInterpreter = this;
+  var myJSON = thisInterpreter.createObjectProto(this.OBJECT_PROTO);
+  this.setProperty(globalObject, "JSON", myJSON, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function parse2(text) {
+    try {
+      var nativeObj = JSON.parse(String(text));
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, e.message);
+    }
+    return thisInterpreter.nativeToPseudo(nativeObj);
+  };
+  this.setProperty(myJSON, "parse", this.createNativeFunction(wrapper, false));
+  wrapper = function stringify(value, replacer, space) {
+    if (replacer && replacer.class === "Function") {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Function replacer on JSON.stringify not supported");
+    } else if (replacer && replacer.class === "Array") {
+      replacer = thisInterpreter.arrayPseudoToNative(replacer);
+      replacer = replacer.filter(function (word) {
+        return typeof word === "string" || typeof word === "number";
+      });
+    } else {
+      replacer = null;
+    }
+    if (typeof space !== "string" && typeof space !== "number") {
+      space = void 0;
+    }
+    var nativeObj = thisInterpreter.pseudoToNative(value);
+    try {
+      var str = JSON.stringify(nativeObj, replacer, space);
+    } catch (e) {
+      thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, e.message);
+    }
+    return str;
+  };
+  this.setProperty(myJSON, "stringify", this.createNativeFunction(wrapper, false));
+};
+Interpreter.prototype.isa = function (child, constructor) {
+  if (child === null || child === void 0 || !constructor) {
+    return false;
+  }
+  var proto = constructor.properties["prototype"];
+  if (child === proto) {
+    return true;
+  }
+  child = this.getPrototype(child);
+  while (child) {
+    if (child === proto) {
+      return true;
+    }
+    child = child.proto;
+  }
+  return false;
+};
+Interpreter.prototype.populateRegExp = function (pseudoRegexp, nativeRegexp) {
+  pseudoRegexp.data = new RegExp(nativeRegexp.source, nativeRegexp.flags);
+  this.setProperty(pseudoRegexp, "lastIndex", nativeRegexp.lastIndex, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(pseudoRegexp, "source", nativeRegexp.source, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(pseudoRegexp, "global", nativeRegexp.global, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(pseudoRegexp, "ignoreCase", nativeRegexp.ignoreCase, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(pseudoRegexp, "multiline", nativeRegexp.multiline, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+};
+Interpreter.prototype.populateError = function (pseudoError, opt_message) {
+  if (opt_message) {
+    this.setProperty(pseudoError, "message", String(opt_message), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  }
+  var tracebackData = [];
+  for (var i = this.stateStack.length - 1; i >= 0; i--) {
+    var state = this.stateStack[i];
+    var node = state.node;
+    if (node.type === "CallExpression") {
+      var func = state.func_;
+      if (func && tracebackData.length) {
+        tracebackData[tracebackData.length - 1].datumName = this.getProperty(func, "name");
+      }
+    }
+    if (node.loc && (!tracebackData.length || node.type === "CallExpression")) {
+      tracebackData.push({
+        datumLoc: node.loc
+      });
+    }
+  }
+  var errorName = String(this.getProperty(pseudoError, "name"));
+  var errorMessage = String(this.getProperty(pseudoError, "message"));
+  var stackString = errorName + ": " + errorMessage + "\n";
+  for (var i = 0; i < tracebackData.length; i++) {
+    var loc = tracebackData[i].datumLoc;
+    var name = tracebackData[i].datumName;
+    var locString = loc.source + ":" + loc.start.line + ":" + loc.start.column;
+    if (name) {
+      stackString += "  at " + name + " (" + locString + ")\n";
+    } else {
+      stackString += "  at " + locString + "\n";
+    }
+  }
+  this.setProperty(pseudoError, "stack", stackString.trim(), Interpreter.NONENUMERABLE_DESCRIPTOR);
+};
+Interpreter.prototype.createWorker = function () {
+  var blob = this.createWorker.blob_;
+  if (!blob) {
+    blob = new Blob([Interpreter.WORKER_CODE.join("\n")], {
+      type: "application/javascript"
+    });
+    this.createWorker.blob_ = blob;
+  }
+  return new Worker(URL.createObjectURL(blob));
+};
+Interpreter.prototype.vmCall = function (code, sandbox, nativeRegExp, callback) {
+  var options = {
+    timeout: this["REGEXP_THREAD_TIMEOUT"]
+  };
+  try {
+    return Interpreter.vm["runInNewContext"](code, sandbox, options);
+  } catch (_e) {
+    callback(null);
+    this.throwException(this.ERROR, "RegExp Timeout: " + nativeRegExp);
+  }
+  return Interpreter.REGEXP_TIMEOUT;
+};
+Interpreter.prototype.maybeThrowRegExp = function (nativeRegExp, callback) {
+  var ok;
+  if (this["REGEXP_MODE"] === 0) {
+    ok = false;
+  } else if (this["REGEXP_MODE"] === 1) {
+    ok = true;
+  } else {
+    if (Interpreter.vm) {
+      ok = true;
+    } else if (typeof Worker === "function" && typeof URL === "function") {
+      ok = true;
+    } else if (typeof require === "function") {
+      try {
+        Interpreter.vm = require("vm");
+      } catch (_e) {}
+      ok = !!Interpreter.vm;
+    } else {
+      ok = false;
+    }
+  }
+  if (!ok) {
+    callback(null);
+    this.throwException(this.ERROR, "Regular expressions not supported: " + nativeRegExp);
+  }
+};
+Interpreter.prototype.regExpTimeout = function (nativeRegExp, worker, callback) {
+  var thisInterpreter = this;
+  return setTimeout(function () {
+    worker.terminate();
+    callback(null);
+    try {
+      thisInterpreter.throwException(thisInterpreter.ERROR, "RegExp Timeout: " + nativeRegExp);
+    } catch (_e) {}
+  }, this["REGEXP_THREAD_TIMEOUT"]);
+};
+Interpreter.prototype.createObject = function (constructor) {
+  return this.createObjectProto(constructor && constructor.properties["prototype"]);
+};
+Interpreter.prototype.createObjectProto = function (proto) {
+  if (typeof proto !== "object") {
+    throw Error("Non object prototype");
+  }
+  var obj = new Interpreter.Object(proto);
+  if (this.isa(obj, this.ERROR)) {
+    obj.class = "Error";
+  }
+  return obj;
+};
+Interpreter.prototype.createArray = function () {
+  var array = this.createObjectProto(this.ARRAY_PROTO);
+  this.setProperty(array, "length", 0, {
+    configurable: false,
+    enumerable: false,
+    writable: true
+  });
+  array.class = "Array";
+  return array;
+};
+Interpreter.prototype.createFunctionBase_ = function (argumentLength, isConstructor) {
+  var func = this.createObjectProto(this.FUNCTION_PROTO);
+  if (isConstructor) {
+    var proto = this.createObjectProto(this.OBJECT_PROTO);
+    this.setProperty(func, "prototype", proto, Interpreter.NONENUMERABLE_DESCRIPTOR);
+    this.setProperty(proto, "constructor", func, Interpreter.NONENUMERABLE_DESCRIPTOR);
+  } else {
+    func.illegalConstructor = true;
+  }
+  this.setProperty(func, "length", argumentLength, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  func.class = "Function";
+  return func;
+};
+Interpreter.prototype.createFunction = function (node, scope, opt_name) {
+  var func = this.createFunctionBase_(node.params.length, true);
+  func.parentScope = scope;
+  func.node = node;
+  var name = node.id ? String(node.id.name) : opt_name || "";
+  this.setProperty(func, "name", name, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  return func;
+};
+Interpreter.prototype.createNativeFunction = function (nativeFunc, isConstructor) {
+  var func = this.createFunctionBase_(nativeFunc.length, isConstructor);
+  func.nativeFunc = nativeFunc;
+  nativeFunc.id = this.functionCounter_++;
+  this.setProperty(func, "name", nativeFunc.name, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  return func;
+};
+Interpreter.prototype.createAsyncFunction = function (asyncFunc) {
+  var func = this.createFunctionBase_(asyncFunc.length, true);
+  func.asyncFunc = asyncFunc;
+  asyncFunc.id = this.functionCounter_++;
+  this.setProperty(func, "name", asyncFunc.name, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  return func;
+};
+Interpreter.prototype.nativeToPseudo = function (nativeObj) {
+  if (nativeObj instanceof Interpreter.Object) {
+    throw Error("Object is already pseudo");
+  }
+  if (nativeObj === null || nativeObj === void 0 || nativeObj === true || nativeObj === false || typeof nativeObj === "string" || typeof nativeObj === "number") {
+    return nativeObj;
+  }
+  if (nativeObj instanceof RegExp) {
+    var pseudoRegexp = this.createObjectProto(this.REGEXP_PROTO);
+    this.populateRegExp(pseudoRegexp, nativeObj);
+    return pseudoRegexp;
+  }
+  if (nativeObj instanceof Date) {
+    var pseudoDate = this.createObjectProto(this.DATE_PROTO);
+    pseudoDate.data = new Date(nativeObj.valueOf());
+    return pseudoDate;
+  }
+  if (typeof nativeObj === "function") {
+    var thisInterpreter = this;
+    var wrapper = function () {
+      var args = Array.prototype.slice.call(arguments).map(function (i2) {
+        return thisInterpreter.pseudoToNative(i2);
+      });
+      var value = nativeObj.apply(thisInterpreter, args);
+      return thisInterpreter.nativeToPseudo(value);
+    };
+    var prototype = Object.getOwnPropertyDescriptor(nativeObj, "prototype");
+    return this.createNativeFunction(wrapper, !!prototype);
+  }
+  if (Array.isArray(nativeObj)) {
+    var pseudoArray = this.createArray();
+    for (var i = 0; i < nativeObj.length; i++) {
+      if (i in nativeObj) {
+        this.setProperty(pseudoArray, i, this.nativeToPseudo(nativeObj[i]));
+      }
+    }
+    return pseudoArray;
+  }
+  var pseudoObj = this.createObjectProto(this.OBJECT_PROTO);
+  for (var key in nativeObj) {
+    this.setProperty(pseudoObj, key, this.nativeToPseudo(nativeObj[key]));
+  }
+  return pseudoObj;
+};
+Interpreter.prototype.pseudoToNative = function (pseudoObj, opt_cycles) {
+  if (typeof pseudoObj !== "object" && typeof pseudoObj !== "function" || pseudoObj === null) {
+    return pseudoObj;
+  }
+  if (!(pseudoObj instanceof Interpreter.Object)) {
+    throw Error("Object is not pseudo");
+  }
+  if (this.isa(pseudoObj, this.REGEXP)) {
+    var nativeRegExp = new RegExp(pseudoObj.data.source, pseudoObj.data.flags);
+    nativeRegExp.lastIndex = pseudoObj.data.lastIndex;
+    return nativeRegExp;
+  }
+  if (this.isa(pseudoObj, this.DATE)) {
+    return new Date(pseudoObj.data.valueOf());
+  }
+  var cycles = opt_cycles || {
+    pseudo: [],
+    native: []
+  };
+  var index = cycles.pseudo.indexOf(pseudoObj);
+  if (index !== -1) {
+    return cycles.native[index];
+  }
+  cycles.pseudo.push(pseudoObj);
+  var nativeObj;
+  if (this.isa(pseudoObj, this.ARRAY)) {
+    nativeObj = [];
+    cycles.native.push(nativeObj);
+    var len = this.getProperty(pseudoObj, "length");
+    for (var i = 0; i < len; i++) {
+      if (this.hasProperty(pseudoObj, i)) {
+        nativeObj[i] = this.pseudoToNative(this.getProperty(pseudoObj, i), cycles);
+      }
+    }
+  } else {
+    nativeObj = {};
+    cycles.native.push(nativeObj);
+    var val;
+    for (var key in pseudoObj.properties) {
+      val = this.pseudoToNative(pseudoObj.properties[key], cycles);
+      Object.defineProperty(nativeObj, key, {
+        value: val,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  cycles.pseudo.pop();
+  cycles.native.pop();
+  return nativeObj;
+};
+Interpreter.prototype.arrayNativeToPseudo = function (nativeArray) {
+  var pseudoArray = this.createArray();
+  var props = Object.getOwnPropertyNames(nativeArray);
+  for (var i = 0; i < props.length; i++) {
+    this.setProperty(pseudoArray, props[i], nativeArray[props[i]]);
+  }
+  return pseudoArray;
+};
+Interpreter.prototype.arrayPseudoToNative = function (pseudoArray) {
+  var nativeArray = [];
+  for (var key in pseudoArray.properties) {
+    nativeArray[key] = this.getProperty(pseudoArray, key);
+  }
+  nativeArray.length = Interpreter.legalArrayLength(this.getProperty(pseudoArray, "length")) || 0;
+  return nativeArray;
+};
+Interpreter.prototype.getPrototype = function (value) {
+  switch (typeof value) {
+    case "number":
+      return this.NUMBER.properties["prototype"];
+    case "boolean":
+      return this.BOOLEAN.properties["prototype"];
+    case "string":
+      return this.STRING.properties["prototype"];
+  }
+  if (value) {
+    return value.proto;
+  }
+  return null;
+};
+Interpreter.prototype.getProperty = function (obj, name) {
+  if (this.getterStep_) {
+    throw Error("Getter not supported in that context");
+  }
+  name = String(name);
+  if (obj === void 0 || obj === null) {
+    this.throwException(this.TYPE_ERROR, "Cannot read property '" + name + "' of " + obj);
+  }
+  if (typeof obj === "object" && !(obj instanceof Interpreter.Object)) {
+    throw TypeError("Expecting native value or pseudo object");
+  }
+  if (name === "length") {
+    if (this.isa(obj, this.STRING)) {
+      return String(obj).length;
+    }
+  } else if (name.charCodeAt(0) < 64) {
+    if (this.isa(obj, this.STRING)) {
+      var n = Interpreter.legalArrayIndex(name);
+      if (!isNaN(n) && n < String(obj).length) {
+        return String(obj)[n];
+      }
+    }
+  }
+  do {
+    if (obj.properties && name in obj.properties) {
+      var getter = obj.getter[name];
+      if (getter) {
+        this.getterStep_ = true;
+        return getter;
+      }
+      return obj.properties[name];
+    }
+  } while (obj = this.getPrototype(obj));
+  return void 0;
+};
+Interpreter.prototype.hasProperty = function (obj, name) {
+  if (!(obj instanceof Interpreter.Object)) {
+    throw TypeError("Primitive data type has no properties");
+  }
+  name = String(name);
+  if (name === "length" && this.isa(obj, this.STRING)) {
+    return true;
+  }
+  if (this.isa(obj, this.STRING)) {
+    var n = Interpreter.legalArrayIndex(name);
+    if (!isNaN(n) && n < String(obj).length) {
+      return true;
+    }
+  }
+  do {
+    if (obj.properties && name in obj.properties) {
+      return true;
+    }
+  } while (obj = this.getPrototype(obj));
+  return false;
+};
+Interpreter.prototype.setProperty = function (obj, name, value, opt_descriptor) {
+  if (this.setterStep_) {
+    throw Error("Setter not supported in that context");
+  }
+  name = String(name);
+  if (obj === void 0 || obj === null) {
+    this.throwException(this.TYPE_ERROR, "Cannot set property '" + name + "' of " + obj);
+  }
+  if (typeof obj === "object" && !(obj instanceof Interpreter.Object)) {
+    throw TypeError("Expecting native value or pseudo object");
+  }
+  if (opt_descriptor && ("get" in opt_descriptor || "set" in opt_descriptor) && ("value" in opt_descriptor || "writable" in opt_descriptor)) {
+    this.throwException(this.TYPE_ERROR, "Invalid property descriptor. Cannot both specify accessors and a value or writable attribute");
+  }
+  var strict = !this.stateStack || this.getScope().strict;
+  if (!(obj instanceof Interpreter.Object)) {
+    if (strict) {
+      this.throwException(this.TYPE_ERROR, "Can't create property '" + name + "' on '" + obj + "'");
+    }
+    return;
+  }
+  if (this.isa(obj, this.STRING)) {
+    var n = Interpreter.legalArrayIndex(name);
+    if (name === "length" || !isNaN(n) && n < String(obj).length) {
+      if (strict) {
+        this.throwException(this.TYPE_ERROR, "Cannot assign to read only property '" + name + "' of String '" + obj.data + "'");
+      }
+      return;
+    }
+  }
+  if (obj.class === "Array") {
+    var len = obj.properties.length;
+    var i;
+    if (name === "length") {
+      if (opt_descriptor) {
+        if (!("value" in opt_descriptor)) {
+          return;
+        }
+        value = opt_descriptor["value"];
+      }
+      value = Interpreter.legalArrayLength(value);
+      if (isNaN(value)) {
+        this.throwException(this.RANGE_ERROR, "Invalid array length");
+      }
+      if (value < len) {
+        for (i in obj.properties) {
+          i = Interpreter.legalArrayIndex(i);
+          if (!isNaN(i) && value <= i) {
+            delete obj.properties[i];
+          }
+        }
+      }
+    } else if (!isNaN(i = Interpreter.legalArrayIndex(name))) {
+      obj.properties.length = Math.max(len, i + 1);
+    }
+  }
+  if (obj.preventExtensions && !(name in obj.properties)) {
+    if (strict) {
+      this.throwException(this.TYPE_ERROR, "Can't add property '" + name + "', object is not extensible");
+    }
+    return;
+  }
+  if (opt_descriptor) {
+    var descriptor = {};
+    if ("get" in opt_descriptor && opt_descriptor["get"]) {
+      obj.getter[name] = opt_descriptor["get"];
+      descriptor["get"] = this.setProperty.placeholderGet_;
+    }
+    if ("set" in opt_descriptor && opt_descriptor["set"]) {
+      obj.setter[name] = opt_descriptor["set"];
+      descriptor["set"] = this.setProperty.placeholderSet_;
+    }
+    if ("configurable" in opt_descriptor) {
+      descriptor["configurable"] = opt_descriptor["configurable"];
+    }
+    if ("enumerable" in opt_descriptor) {
+      descriptor["enumerable"] = opt_descriptor["enumerable"];
+    }
+    if ("writable" in opt_descriptor) {
+      descriptor["writable"] = opt_descriptor["writable"];
+      delete obj.getter[name];
+      delete obj.setter[name];
+    }
+    if ("value" in opt_descriptor) {
+      descriptor["value"] = opt_descriptor["value"];
+      delete obj.getter[name];
+      delete obj.setter[name];
+    } else if (value !== Interpreter.VALUE_IN_DESCRIPTOR) {
+      descriptor["value"] = value;
+      delete obj.getter[name];
+      delete obj.setter[name];
+    }
+    try {
+      Object.defineProperty(obj.properties, name, descriptor);
+    } catch (e) {
+      this.throwException(this.TYPE_ERROR, "Cannot redefine property: " + name);
+    }
+    if ("get" in opt_descriptor && !opt_descriptor["get"]) {
+      delete obj.getter[name];
+    }
+    if ("set" in opt_descriptor && !opt_descriptor["set"]) {
+      delete obj.setter[name];
+    }
+  } else {
+    if (value === Interpreter.VALUE_IN_DESCRIPTOR) {
+      throw ReferenceError("Value not specified");
+    }
+    var defObj = obj;
+    while (!(name in defObj.properties)) {
+      defObj = this.getPrototype(defObj);
+      if (!defObj) {
+        defObj = obj;
+        break;
+      }
+    }
+    if (defObj.setter && defObj.setter[name]) {
+      this.setterStep_ = true;
+      return defObj.setter[name];
+    }
+    if (defObj.getter && defObj.getter[name]) {
+      if (strict) {
+        this.throwException(this.TYPE_ERROR, "Cannot set property '" + name + "' of object '" + obj + "' which only has a getter");
+      }
+    } else {
+      try {
+        obj.properties[name] = value;
+      } catch (_e) {
+        if (strict) {
+          this.throwException(this.TYPE_ERROR, "Cannot assign to read only property '" + name + "' of object '" + obj + "'");
+        }
+      }
+    }
+  }
+};
+Interpreter.prototype.setProperty.placeholderGet_ = function () {
+  throw Error("Placeholder getter");
+};
+Interpreter.prototype.setProperty.placeholderSet_ = function () {
+  throw Error("Placeholder setter");
+};
+Interpreter.prototype.setNativeFunctionPrototype = function (obj, name, wrapper) {
+  this.setProperty(obj.properties["prototype"], name, this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+};
+Interpreter.prototype.setAsyncFunctionPrototype = function (obj, name, wrapper) {
+  this.setProperty(obj.properties["prototype"], name, this.createAsyncFunction(wrapper), Interpreter.NONENUMERABLE_DESCRIPTOR);
+};
+Interpreter.prototype.getScope = function () {
+  var scope = this.stateStack[this.stateStack.length - 1].scope;
+  if (!scope) {
+    throw Error("No scope found");
+  }
+  return scope;
+};
+Interpreter.prototype.createScope = function (node, parentScope) {
+  var strict = false;
+  if (parentScope && parentScope.strict) {
+    strict = true;
+  } else {
+    var firstNode = node.body && node.body[0];
+    if (firstNode && firstNode.expression && firstNode.expression.type === "Literal" && firstNode.expression.value === "use strict") {
+      strict = true;
+    }
+  }
+  var object = this.createObjectProto(null);
+  var scope = new Interpreter.Scope(parentScope, strict, object);
+  if (!parentScope) {
+    this.initGlobal(scope.object);
+  }
+  this.populateScope_(node, scope);
+  return scope;
+};
+Interpreter.prototype.createSpecialScope = function (parentScope, opt_object) {
+  if (!parentScope) {
+    throw Error("parentScope required");
+  }
+  var object = opt_object || this.createObjectProto(null);
+  return new Interpreter.Scope(parentScope, parentScope.strict, object);
+};
+Interpreter.prototype.getValueFromScope = function (name) {
+  var scope = this.getScope();
+  while (scope && scope !== this.globalScope) {
+    if (name in scope.object.properties) {
+      return scope.object.properties[name];
+    }
+    scope = scope.parentScope;
+  }
+  if (scope === this.globalScope && this.hasProperty(scope.object, name)) {
+    return this.getProperty(scope.object, name);
+  }
+  var prevNode = this.stateStack[this.stateStack.length - 1].node;
+  if (prevNode.type === "UnaryExpression" && prevNode.operator === "typeof") {
+    return void 0;
+  }
+  this.throwException(this.REFERENCE_ERROR, name + " is not defined");
+};
+Interpreter.prototype.setValueToScope = function (name, value) {
+  var scope = this.getScope();
+  var strict = scope.strict;
+  while (scope && scope !== this.globalScope) {
+    if (name in scope.object.properties) {
+      try {
+        scope.object.properties[name] = value;
+      } catch (_e) {
+        if (strict) {
+          this.throwException(this.TYPE_ERROR, "Cannot assign to read only variable '" + name + "'");
+        }
+      }
+      return void 0;
+    }
+    scope = scope.parentScope;
+  }
+  if (scope === this.globalScope && (!strict || this.hasProperty(scope.object, name))) {
+    return this.setProperty(scope.object, name, value);
+  }
+  this.throwException(this.REFERENCE_ERROR, name + " is not defined");
+};
+Interpreter.prototype.populateScope_ = function (node, scope) {
+  var variableCache;
+  if (!node.variableCache_) {
+    variableCache = Object.create(null);
+    switch (node.type) {
+      case "VariableDeclaration":
+        for (var i = 0; i < node.declarations.length; i++) {
+          variableCache[node.declarations[i].id.name] = true;
+        }
+        break;
+      case "FunctionDeclaration":
+        variableCache[node.id.name] = node;
+        break;
+      case "BlockStatement":
+      case "CatchClause":
+      case "DoWhileStatement":
+      case "ForInStatement":
+      case "ForStatement":
+      case "IfStatement":
+      case "LabeledStatement":
+      case "Program":
+      case "SwitchCase":
+      case "SwitchStatement":
+      case "TryStatement":
+      case "WithStatement":
+      case "WhileStatement":
+        var nodeClass = node.constructor;
+        for (var name in node) {
+          if (name === "loc") continue;
+          var prop = node[name];
+          if (prop && typeof prop === "object") {
+            var childCache;
+            if (Array.isArray(prop)) {
+              for (var i = 0; i < prop.length; i++) {
+                if (prop[i] && prop[i].constructor === nodeClass) {
+                  childCache = this.populateScope_(prop[i], scope);
+                  for (var name in childCache) {
+                    variableCache[name] = childCache[name];
+                  }
+                }
+              }
+            } else {
+              if (prop.constructor === nodeClass) {
+                childCache = this.populateScope_(prop, scope);
+                for (var name in childCache) {
+                  variableCache[name] = childCache[name];
+                }
+              }
+            }
+          }
+        }
+    }
+    node.variableCache_ = variableCache;
+  } else {
+    variableCache = node.variableCache_;
+  }
+  for (var name in variableCache) {
+    if (variableCache[name] === true) {
+      this.setProperty(scope.object, name, void 0, Interpreter.VARIABLE_DESCRIPTOR);
+    } else {
+      this.setProperty(scope.object, name, this.createFunction(variableCache[name], scope), Interpreter.VARIABLE_DESCRIPTOR);
+    }
+  }
+  return variableCache;
+};
+Interpreter.prototype.calledWithNew = function () {
+  return this.stateStack[this.stateStack.length - 1].isConstructor;
+};
+Interpreter.prototype.getValue = function (ref) {
+  if (ref[0] === Interpreter.SCOPE_REFERENCE) {
+    return this.getValueFromScope(ref[1]);
+  } else {
+    return this.getProperty(ref[0], ref[1]);
+  }
+};
+Interpreter.prototype.setValue = function (ref, value) {
+  if (ref[0] === Interpreter.SCOPE_REFERENCE) {
+    return this.setValueToScope(ref[1], value);
+  }
+  return this.setProperty(ref[0], ref[1], value);
+};
+Interpreter.prototype.throwException = function (errorClass, opt_message) {
+  if (!this.globalScope) {
+    throw opt_message === void 0 ? errorClass : opt_message;
+  }
+  if (opt_message === void 0 || !(errorClass instanceof Interpreter.Object)) {
+    var error = errorClass;
+  } else {
+    var error = this.createObject(errorClass);
+    this.populateError(error, opt_message);
+  }
+  this.unwind(Interpreter.Completion.THROW, error, void 0);
+  throw Interpreter.STEP_ERROR;
+};
+Interpreter.prototype.unwind = function (type, value, label) {
+  if (type === Interpreter.Completion.NORMAL) {
+    throw TypeError("Should not unwind for NORMAL completions");
+  }
+  loop: for (var stack = this.stateStack; stack.length > 0; stack.pop()) {
+    var state = stack[stack.length - 1];
+    switch (state.node.type) {
+      case "TryStatement":
+        state.cv = {
+          type,
+          value,
+          label
+        };
+        return;
+      case "CallExpression":
+      case "NewExpression":
+        if (type === Interpreter.Completion.RETURN) {
+          state.value = value;
+          return;
+        } else if (type !== Interpreter.Completion.THROW) {
+          throw Error("Unsynatctic break/continue not rejected by Acorn");
+        }
+        break;
+      case "Program":
+        state.done = true;
+        break loop;
+    }
+    if (type === Interpreter.Completion.BREAK) {
+      if (label ? state.labels && state.labels.indexOf(label) !== -1 : state.isLoop || state.isSwitch) {
+        stack.pop();
+        return;
+      }
+    } else if (type === Interpreter.Completion.CONTINUE) {
+      if (label ? state.labels && state.labels.indexOf(label) !== -1 : state.isLoop) {
+        return;
+      }
+    }
+  }
+  var realError;
+  if (this.isa(value, this.ERROR)) {
+    var errorTable = {
+      EvalError,
+      RangeError,
+      ReferenceError,
+      SyntaxError,
+      TypeError,
+      URIError
+    };
+    var name = String(this.getProperty(value, "name"));
+    var message = this.getProperty(value, "message").valueOf();
+    var errorConstructor = errorTable[name] || Error;
+    realError = errorConstructor(message);
+    realError.stack = String(this.getProperty(value, "stack"));
+  } else {
+    realError = String(value);
+  }
+  this.value = realError;
+  throw realError;
+};
+Interpreter.prototype.nodeSummary = function (node) {
+  switch (node.type) {
+    case "ArrayExpression":
+      return "[...]";
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return this.nodeSummary(node.left) + " " + node.operator + " " + this.nodeSummary(node.right);
+    case "CallExpression":
+      return this.nodeSummary(node.callee) + "(...)";
+    case "ConditionalExpression":
+      return this.nodeSummary(node.test) + " ? " + this.nodeSummary(node.consequent) + " : " + this.nodeSummary(node.alternate);
+    case "Identifier":
+      return node.name;
+    case "Literal":
+      return node.raw;
+    case "MemberExpression":
+      var obj = this.nodeSummary(node.object);
+      var prop = this.nodeSummary(node.property);
+      return node.computed ? obj + "[" + prop + "]" : obj + "." + prop;
+    case "NewExpression":
+      return "new " + this.nodeSummary(node.callee) + "(...)";
+    case "ObjectExpression":
+      return "{...}";
+    case "ThisExpression":
+      return "this";
+    case "UnaryExpression":
+      return node.operator + " " + this.nodeSummary(node.argument);
+    case "UpdateExpression":
+      var argument = this.nodeSummary(node.argument);
+      return node.prefix ? node.operator + argument : argument + node.operator;
+  }
+  return "???";
+};
+Interpreter.prototype.createGetter_ = function (func, left) {
+  if (!this.getterStep_) {
+    throw Error("Unexpected call to createGetter");
+  }
+  this.getterStep_ = false;
+  var funcThis = Array.isArray(left) ? left[0] : left;
+  var node = this.newNode();
+  node.type = "CallExpression";
+  var state = new Interpreter.State(node, this.stateStack[this.stateStack.length - 1].scope);
+  state.doneCallee_ = 2;
+  state.funcThis_ = funcThis;
+  state.func_ = func;
+  state.doneArgs_ = true;
+  state.arguments_ = [];
+  return state;
+};
+Interpreter.prototype.createSetter_ = function (func, left, value) {
+  if (!this.setterStep_) {
+    throw Error("Unexpected call to createSetter");
+  }
+  this.setterStep_ = false;
+  var funcThis = Array.isArray(left) ? left[0] : this.globalObject;
+  var node = this.newNode();
+  node.type = "CallExpression";
+  var state = new Interpreter.State(node, this.stateStack[this.stateStack.length - 1].scope);
+  state.doneCallee_ = 2;
+  state.funcThis_ = funcThis;
+  state.func_ = func;
+  state.doneArgs_ = true;
+  state.arguments_ = [value];
+  return state;
+};
+Interpreter.prototype.boxThis_ = function (value) {
+  if (value === void 0 || value === null) {
+    return this.globalObject;
+  }
+  if (!(value instanceof Interpreter.Object)) {
+    var box = this.createObjectProto(this.getPrototype(value));
+    box.data = value;
+    return box;
+  }
+  return value;
+};
+Interpreter.prototype.getGlobalScope = function () {
+  return this.globalScope;
+};
+Interpreter.prototype.getStateStack = function () {
+  return this.stateStack;
+};
+Interpreter.prototype.setStateStack = function (newStack) {
+  this.stateStack = newStack;
+};
+Interpreter.Value;
+Interpreter.State = function (node, scope) {
+  this.node = node;
+  this.scope = scope;
+};
+Interpreter.Scope = function (parentScope, strict, object) {
+  this.parentScope = parentScope;
+  this.strict = strict;
+  this.object = object;
+};
+Interpreter.Object = function (proto) {
+  this.getter = Object.create(null);
+  this.setter = Object.create(null);
+  this.properties = Object.create(null);
+  this.proto = proto;
+};
+Interpreter.Object.prototype.proto = null;
+Interpreter.Object.prototype.class = "Object";
+Interpreter.Object.prototype.data = null;
+Interpreter.Object.prototype.toString = function () {
+  if (!Interpreter.currentInterpreter_) {
+    return "[object Interpreter.Object]";
+  }
+  if (!(this instanceof Interpreter.Object)) {
+    return String(this);
+  }
+  if (this.class === "Array") {
+    var cycles = Interpreter.toStringCycles_;
+    cycles.push(this);
+    try {
+      var strs = [];
+      var maxLength = this.properties.length;
+      var truncated = false;
+      if (maxLength > 1024) {
+        maxLength = 1e3;
+        truncated = true;
+      }
+      for (var i = 0; i < maxLength; i++) {
+        var value = this.properties[i];
+        strs[i] = value instanceof Interpreter.Object && cycles.indexOf(value) !== -1 ? "..." : value;
+      }
+      if (truncated) {
+        strs.push("...");
+      }
+    } finally {
+      cycles.pop();
+    }
+    return strs.join(",");
+  }
+  if (this.class === "Error") {
+    var cycles = Interpreter.toStringCycles_;
+    if (cycles.indexOf(this) !== -1) {
+      return "[object Error]";
+    }
+    var name, message;
+    var obj = this;
+    do {
+      if ("name" in obj.properties) {
+        name = obj.properties.name;
+        break;
+      }
+    } while (obj = obj.proto);
+    obj = this;
+    do {
+      if ("message" in obj.properties) {
+        message = obj.properties.message;
+        break;
+      }
+    } while (obj = obj.proto);
+    cycles.push(this);
+    try {
+      name = name && String(name);
+      message = message && String(message);
+    } finally {
+      cycles.pop();
+    }
+    return message ? name + ": " + message : String(name);
+  }
+  if (this.data !== null) {
+    return String(this.data);
+  }
+  return "[object " + this.class + "]";
+};
+Interpreter.Object.prototype.valueOf = function () {
+  if (!Interpreter.currentInterpreter_) {
+    return this;
+  }
+  if (this.data === void 0 || this.data === null || this.data instanceof RegExp) {
+    return this;
+  }
+  if (this.data instanceof Date) {
+    return this.data.valueOf();
+  }
+  return this.data;
+};
+Interpreter.prototype["stepArrayExpression"] = function (stack, state, node) {
+  var elements = node.elements;
+  var n = state.n_ || 0;
+  if (!state.array_) {
+    state.array_ = this.createArray();
+    state.array_.properties.length = elements.length;
+  } else {
+    this.setProperty(state.array_, n, state.value);
+    n++;
+  }
+  while (n < elements.length) {
+    if (elements[n]) {
+      state.n_ = n;
+      return new Interpreter.State(elements[n], state.scope);
+    }
+    n++;
+  }
+  stack.pop();
+  stack[stack.length - 1].value = state.array_;
+};
+Interpreter.prototype["stepAssignmentExpression"] = function (stack, state, node) {
+  if (!state.doneLeft_) {
+    state.doneLeft_ = true;
+    var nextState = new Interpreter.State(node.left, state.scope);
+    nextState.components = true;
+    return nextState;
+  }
+  if (!state.doneRight_) {
+    if (!state.leftReference_) {
+      state.leftReference_ = state.value;
+    }
+    if (state.doneGetter_) {
+      state.leftValue_ = state.value;
+    }
+    if (!state.doneGetter_ && node.operator !== "=") {
+      var leftValue = this.getValue(state.leftReference_);
+      state.leftValue_ = leftValue;
+      if (this.getterStep_) {
+        state.doneGetter_ = true;
+        var func = leftValue;
+        return this.createGetter_(func, state.leftReference_);
+      }
+    }
+    state.doneRight_ = true;
+    if (node.operator === "=" && node.left.type === "Identifier") {
+      state.destinationName = node.left.name;
+    }
+    return new Interpreter.State(node.right, state.scope);
+  }
+  if (state.doneSetter_) {
+    stack.pop();
+    stack[stack.length - 1].value = state.setterValue_;
+    return;
+  }
+  var value = state.leftValue_;
+  var rightValue = state.value;
+  switch (node.operator) {
+    case "=":
+      value = rightValue;
+      break;
+    case "+=":
+      value += rightValue;
+      break;
+    case "-=":
+      value -= rightValue;
+      break;
+    case "*=":
+      value *= rightValue;
+      break;
+    case "/=":
+      value /= rightValue;
+      break;
+    case "%=":
+      value %= rightValue;
+      break;
+    case "<<=":
+      value <<= rightValue;
+      break;
+    case ">>=":
+      value >>= rightValue;
+      break;
+    case ">>>=":
+      value >>>= rightValue;
+      break;
+    case "&=":
+      value &= rightValue;
+      break;
+    case "^=":
+      value ^= rightValue;
+      break;
+    case "|=":
+      value |= rightValue;
+      break;
+    default:
+      throw SyntaxError("Unknown assignment expression: " + node.operator);
+  }
+  var setter = this.setValue(state.leftReference_, value);
+  if (setter) {
+    state.doneSetter_ = true;
+    state.setterValue_ = value;
+    return this.createSetter_(setter, state.leftReference_, value);
+  }
+  stack.pop();
+  stack[stack.length - 1].value = value;
+};
+Interpreter.prototype["stepBinaryExpression"] = function (stack, state, node) {
+  if (!state.doneLeft_) {
+    state.doneLeft_ = true;
+    return new Interpreter.State(node.left, state.scope);
+  }
+  if (!state.doneRight_) {
+    state.doneRight_ = true;
+    state.leftValue_ = state.value;
+    return new Interpreter.State(node.right, state.scope);
+  }
+  stack.pop();
+  var leftValue = state.leftValue_;
+  var rightValue = state.value;
+  var value;
+  switch (node.operator) {
+    case "==":
+      value = leftValue == rightValue;
+      break;
+    case "!=":
+      value = leftValue != rightValue;
+      break;
+    case "===":
+      value = leftValue === rightValue;
+      break;
+    case "!==":
+      value = leftValue !== rightValue;
+      break;
+    case ">":
+      value = leftValue > rightValue;
+      break;
+    case ">=":
+      value = leftValue >= rightValue;
+      break;
+    case "<":
+      value = leftValue < rightValue;
+      break;
+    case "<=":
+      value = leftValue <= rightValue;
+      break;
+    case "+":
+      value = leftValue + rightValue;
+      break;
+    case "-":
+      value = leftValue - rightValue;
+      break;
+    case "*":
+      value = leftValue * rightValue;
+      break;
+    case "/":
+      value = leftValue / rightValue;
+      break;
+    case "%":
+      value = leftValue % rightValue;
+      break;
+    case "&":
+      value = leftValue & rightValue;
+      break;
+    case "|":
+      value = leftValue | rightValue;
+      break;
+    case "^":
+      value = leftValue ^ rightValue;
+      break;
+    case "<<":
+      value = leftValue << rightValue;
+      break;
+    case ">>":
+      value = leftValue >> rightValue;
+      break;
+    case ">>>":
+      value = leftValue >>> rightValue;
+      break;
+    case "in":
+      if (!(rightValue instanceof Interpreter.Object)) {
+        this.throwException(this.TYPE_ERROR, "'in' expects an object, not '" + rightValue + "'");
+      }
+      value = this.hasProperty(rightValue, leftValue);
+      break;
+    case "instanceof":
+      if (!this.isa(rightValue, this.FUNCTION)) {
+        this.throwException(this.TYPE_ERROR, "'instanceof' expects an object, not '" + rightValue + "'");
+      }
+      value = leftValue instanceof Interpreter.Object ? this.isa(leftValue, rightValue) : false;
+      break;
+    default:
+      throw SyntaxError("Unknown binary operator: " + node.operator);
+  }
+  stack[stack.length - 1].value = value;
+};
+Interpreter.prototype["stepBlockStatement"] = function (stack, state, node) {
+  var n = state.n_ || 0;
+  var expression = node.body[n];
+  if (expression) {
+    state.n_ = n + 1;
+    return new Interpreter.State(expression, state.scope);
+  }
+  stack.pop();
+};
+Interpreter.prototype["stepBreakStatement"] = function (stack, state, node) {
+  var label = node.label && node.label.name;
+  this.unwind(Interpreter.Completion.BREAK, void 0, label);
+};
+Interpreter.prototype.evalCodeNumber_ = 0;
+Interpreter.prototype["stepCallExpression"] = function (stack, state, node) {
+  if (!state.doneCallee_) {
+    state.doneCallee_ = 1;
+    var nextState = new Interpreter.State(node.callee, state.scope);
+    nextState.components = true;
+    return nextState;
+  }
+  if (state.doneCallee_ === 1) {
+    state.doneCallee_ = 2;
+    var func = state.value;
+    if (Array.isArray(func)) {
+      state.func_ = this.getValue(func);
+      if (func[0] === Interpreter.SCOPE_REFERENCE) {
+        state.directEval_ = func[1] === "eval";
+      } else {
+        state.funcThis_ = func[0];
+      }
+      func = state.func_;
+      if (this.getterStep_) {
+        state.doneCallee_ = 1;
+        return this.createGetter_(func, state.value);
+      }
+    } else {
+      state.func_ = func;
+    }
+    state.arguments_ = [];
+    state.n_ = 0;
+  }
+  var func = state.func_;
+  if (!state.doneArgs_) {
+    if (state.n_ !== 0) {
+      state.arguments_.push(state.value);
+    }
+    if (node.arguments[state.n_]) {
+      return new Interpreter.State(node.arguments[state.n_++], state.scope);
+    }
+    if (node.type === "NewExpression") {
+      if (!(func instanceof Interpreter.Object) || func.illegalConstructor) {
+        this.throwException(this.TYPE_ERROR, this.nodeSummary(node.callee) + " is not a constructor");
+      }
+      if (func === this.ARRAY) {
+        state.funcThis_ = this.createArray();
+      } else {
+        var proto = func.properties["prototype"];
+        if (typeof proto !== "object" || proto === null) {
+          proto = this.OBJECT_PROTO;
+        }
+        state.funcThis_ = this.createObjectProto(proto);
+      }
+      state.isConstructor = true;
+    }
+    state.doneArgs_ = true;
+  }
+  if (!state.doneExec_) {
+    state.doneExec_ = true;
+    if (!(func instanceof Interpreter.Object)) {
+      this.throwException(this.TYPE_ERROR, this.nodeSummary(node.callee) + " is not a function");
+    }
+    var funcNode = func.node;
+    if (funcNode) {
+      var scope = this.createScope(funcNode.body, func.parentScope);
+      var argsList = this.createArray();
+      for (var i = 0; i < state.arguments_.length; i++) {
+        this.setProperty(argsList, i, state.arguments_[i]);
+      }
+      this.setProperty(scope.object, "arguments", argsList);
+      for (var i = 0; i < funcNode.params.length; i++) {
+        var paramName = funcNode.params[i].name;
+        var paramValue = state.arguments_.length > i ? state.arguments_[i] : void 0;
+        this.setProperty(scope.object, paramName, paramValue);
+      }
+      if (!scope.strict) {
+        state.funcThis_ = this.boxThis_(state.funcThis_);
+      }
+      this.setProperty(scope.object, "this", state.funcThis_, Interpreter.READONLY_DESCRIPTOR);
+      state.value = void 0;
+      return new Interpreter.State(funcNode.body, scope);
+    } else if (func.eval) {
+      var code = state.arguments_[0];
+      if (typeof code !== "string") {
+        state.value = code;
+      } else {
+        try {
+          var ast = this.parse_(String(code), "eval" + this.evalCodeNumber_++);
+        } catch (e) {
+          this.throwException(this.SYNTAX_ERROR, "Invalid code: " + e.message);
+        }
+        var evalNode = this.newNode();
+        evalNode.type = "EvalProgram_";
+        evalNode.body = ast.body;
+        Interpreter.stripLocations_(evalNode, node.start, node.end);
+        var scope = state.directEval_ ? state.scope : this.globalScope;
+        if (scope.strict) {
+          scope = this.createScope(ast, scope);
+        } else {
+          this.populateScope_(ast, scope);
+        }
+        this.value = void 0;
+        return new Interpreter.State(evalNode, scope);
+      }
+    } else if (func.nativeFunc) {
+      if (!state.scope.strict) {
+        state.funcThis_ = this.boxThis_(state.funcThis_);
+      }
+      state.value = func.nativeFunc.apply(state.funcThis_, state.arguments_);
+    } else if (func.asyncFunc) {
+      var thisInterpreter = this;
+      var callback = function (value) {
+        state.value = value;
+        thisInterpreter.paused_ = false;
+      };
+      var argLength = func.asyncFunc.length - 1;
+      var argsWithCallback = state.arguments_.concat(new Array(argLength)).slice(0, argLength);
+      argsWithCallback.push(callback);
+      this.paused_ = true;
+      if (!state.scope.strict) {
+        state.funcThis_ = this.boxThis_(state.funcThis_);
+      }
+      func.asyncFunc.apply(state.funcThis_, argsWithCallback);
+      return;
+    } else {
+      this.throwException(this.TYPE_ERROR, this.nodeSummary(node.callee) + " is not callable");
+    }
+  } else {
+    stack.pop();
+    if (state.isConstructor && typeof state.value !== "object") {
+      stack[stack.length - 1].value = state.funcThis_;
+    } else {
+      stack[stack.length - 1].value = state.value;
+    }
+  }
+};
+Interpreter.prototype["stepConditionalExpression"] = function (stack, state, node) {
+  var mode = state.mode_ || 0;
+  if (mode === 0) {
+    state.mode_ = 1;
+    return new Interpreter.State(node.test, state.scope);
+  }
+  if (mode === 1) {
+    state.mode_ = 2;
+    var value = Boolean(state.value);
+    if (value && node.consequent) {
+      return new Interpreter.State(node.consequent, state.scope);
+    } else if (!value && node.alternate) {
+      return new Interpreter.State(node.alternate, state.scope);
+    }
+    this.value = void 0;
+  }
+  stack.pop();
+  if (node.type === "ConditionalExpression") {
+    stack[stack.length - 1].value = state.value;
+  }
+};
+Interpreter.prototype["stepContinueStatement"] = function (stack, state, node) {
+  var label = node.label && node.label.name;
+  this.unwind(Interpreter.Completion.CONTINUE, void 0, label);
+};
+Interpreter.prototype["stepDebuggerStatement"] = function (stack, state, node) {
+  stack.pop();
+};
+Interpreter.prototype["stepDoWhileStatement"] = function (stack, state, node) {
+  if (node.type === "DoWhileStatement" && state.test_ === void 0) {
+    state.value = true;
+    state.test_ = true;
+  }
+  if (!state.test_) {
+    state.test_ = true;
+    return new Interpreter.State(node.test, state.scope);
+  }
+  if (!state.value) {
+    stack.pop();
+  } else if (node.body) {
+    state.test_ = false;
+    state.isLoop = true;
+    return new Interpreter.State(node.body, state.scope);
+  }
+};
+Interpreter.prototype["stepEmptyStatement"] = function (stack, state, node) {
+  stack.pop();
+};
+Interpreter.prototype["stepEvalProgram_"] = function (stack, state, node) {
+  var n = state.n_ || 0;
+  var expression = node.body[n];
+  if (expression) {
+    state.n_ = n + 1;
+    return new Interpreter.State(expression, state.scope);
+  }
+  stack.pop();
+  stack[stack.length - 1].value = this.value;
+};
+Interpreter.prototype["stepExpressionStatement"] = function (stack, state, node) {
+  if (!state.done_) {
+    this.value = void 0;
+    state.done_ = true;
+    return new Interpreter.State(node.expression, state.scope);
+  }
+  stack.pop();
+  this.value = state.value;
+};
+Interpreter.prototype["stepForInStatement"] = function (stack, state, node) {
+  if (!state.doneInit_) {
+    state.doneInit_ = true;
+    if (node.left.declarations && node.left.declarations[0].init) {
+      if (state.scope.strict) {
+        this.throwException(this.SYNTAX_ERROR, "for-in loop variable declaration may not have an initializer");
+      }
+      return new Interpreter.State(node.left, state.scope);
+    }
+  }
+  if (!state.doneObject_) {
+    state.doneObject_ = true;
+    if (!state.variable_) {
+      state.variable_ = state.value;
+    }
+    return new Interpreter.State(node.right, state.scope);
+  }
+  if (!state.isLoop) {
+    state.isLoop = true;
+    state.object_ = state.value;
+    state.visited_ = Object.create(null);
+  }
+  if (state.name_ === void 0) {
+    gotPropName: while (true) {
+      if (state.object_ instanceof Interpreter.Object) {
+        if (!state.props_) {
+          state.props_ = Object.getOwnPropertyNames(state.object_.properties);
+        }
+        while (true) {
+          var prop = state.props_.shift();
+          if (prop === void 0) {
+            break;
+          }
+          if (!Object.prototype.hasOwnProperty.call(state.object_.properties, prop)) {
+            continue;
+          }
+          if (state.visited_[prop]) {
+            continue;
+          }
+          state.visited_[prop] = true;
+          if (!Object.prototype.propertyIsEnumerable.call(state.object_.properties, prop)) {
+            continue;
+          }
+          state.name_ = prop;
+          break gotPropName;
+        }
+      } else if (state.object_ !== null && state.object_ !== void 0) {
+        if (!state.props_) {
+          state.props_ = Object.getOwnPropertyNames(state.object_);
+        }
+        while (true) {
+          var prop = state.props_.shift();
+          if (prop === void 0) {
+            break;
+          }
+          state.visited_[prop] = true;
+          if (!Object.prototype.propertyIsEnumerable.call(state.object_, prop)) {
+            continue;
+          }
+          state.name_ = prop;
+          break gotPropName;
+        }
+      }
+      state.object_ = this.getPrototype(state.object_);
+      state.props_ = null;
+      if (state.object_ === null) {
+        stack.pop();
+        return;
+      }
+    }
+  }
+  if (!state.doneVariable_) {
+    state.doneVariable_ = true;
+    var left = node.left;
+    if (left.type === "VariableDeclaration") {
+      state.variable_ = [Interpreter.SCOPE_REFERENCE, left.declarations[0].id.name];
+    } else {
+      state.variable_ = null;
+      var nextState = new Interpreter.State(left, state.scope);
+      nextState.components = true;
+      return nextState;
+    }
+  }
+  if (!state.variable_) {
+    state.variable_ = state.value;
+  }
+  if (!state.doneSetter_) {
+    state.doneSetter_ = true;
+    var value = state.name_;
+    var setter = this.setValue(state.variable_, value);
+    if (setter) {
+      return this.createSetter_(setter, state.variable_, value);
+    }
+  }
+  state.name_ = void 0;
+  state.doneVariable_ = false;
+  state.doneSetter_ = false;
+  if (node.body) {
+    return new Interpreter.State(node.body, state.scope);
+  }
+};
+Interpreter.prototype["stepForStatement"] = function (stack, state, node) {
+  switch (state.mode_) {
+    default:
+      state.mode_ = 1;
+      if (node.init) {
+        return new Interpreter.State(node.init, state.scope);
+      }
+      break;
+    case 1:
+      state.mode_ = 2;
+      if (node.test) {
+        return new Interpreter.State(node.test, state.scope);
+      }
+      break;
+    case 2:
+      state.mode_ = 3;
+      if (node.test && !state.value) {
+        stack.pop();
+      } else {
+        state.isLoop = true;
+        return new Interpreter.State(node.body, state.scope);
+      }
+      break;
+    case 3:
+      state.mode_ = 1;
+      if (node.update) {
+        return new Interpreter.State(node.update, state.scope);
+      }
+      break;
+  }
+};
+Interpreter.prototype["stepFunctionDeclaration"] = function (stack, state, node) {
+  stack.pop();
+};
+Interpreter.prototype["stepFunctionExpression"] = function (stack, state, node) {
+  stack.pop();
+  state = stack[stack.length - 1];
+  var parentScope = state.scope;
+  if (node.id) {
+    parentScope = this.createSpecialScope(parentScope);
+  }
+  state.value = this.createFunction(node, parentScope, state.destinationName);
+  if (node.id) {
+    this.setProperty(parentScope.object, node.id.name, state.value, Interpreter.READONLY_DESCRIPTOR);
+  }
+};
+Interpreter.prototype["stepIdentifier"] = function (stack, state, node) {
+  stack.pop();
+  if (state.components) {
+    stack[stack.length - 1].value = [Interpreter.SCOPE_REFERENCE, node.name];
+    return;
+  }
+  var value = this.getValueFromScope(node.name);
+  if (this.getterStep_) {
+    var func = value;
+    return this.createGetter_(func, this.globalObject);
+  }
+  stack[stack.length - 1].value = value;
+};
+Interpreter.prototype["stepIfStatement"] = Interpreter.prototype["stepConditionalExpression"];
+Interpreter.prototype["stepLabeledStatement"] = function (stack, state, node) {
+  stack.pop();
+  var labels = state.labels || [];
+  labels.push(node.label.name);
+  var nextState = new Interpreter.State(node.body, state.scope);
+  nextState.labels = labels;
+  return nextState;
+};
+Interpreter.prototype["stepLiteral"] = function (stack, state, node) {
+  stack.pop();
+  var value = node.value;
+  if (value instanceof RegExp) {
+    var pseudoRegexp = this.createObjectProto(this.REGEXP_PROTO);
+    this.populateRegExp(pseudoRegexp, value);
+    value = pseudoRegexp;
+  }
+  stack[stack.length - 1].value = value;
+};
+Interpreter.prototype["stepLogicalExpression"] = function (stack, state, node) {
+  if (node.operator !== "&&" && node.operator !== "||") {
+    throw SyntaxError("Unknown logical operator: " + node.operator);
+  }
+  if (!state.doneLeft_) {
+    state.doneLeft_ = true;
+    return new Interpreter.State(node.left, state.scope);
+  }
+  if (!state.doneRight_) {
+    if (node.operator === "&&" && !state.value || node.operator === "||" && state.value) {
+      stack.pop();
+      stack[stack.length - 1].value = state.value;
+    } else {
+      state.doneRight_ = true;
+      return new Interpreter.State(node.right, state.scope);
+    }
+  } else {
+    stack.pop();
+    stack[stack.length - 1].value = state.value;
+  }
+};
+Interpreter.prototype["stepMemberExpression"] = function (stack, state, node) {
+  if (!state.doneObject_) {
+    state.doneObject_ = true;
+    return new Interpreter.State(node.object, state.scope);
+  }
+  var propName;
+  if (!node.computed) {
+    state.object_ = state.value;
+    propName = node.property.name;
+  } else if (!state.doneProperty_) {
+    state.object_ = state.value;
+    state.doneProperty_ = true;
+    return new Interpreter.State(node.property, state.scope);
+  } else {
+    propName = state.value;
+  }
+  stack.pop();
+  if (state.components) {
+    stack[stack.length - 1].value = [state.object_, propName];
+  } else {
+    var value = this.getProperty(state.object_, propName);
+    if (this.getterStep_) {
+      var func = value;
+      return this.createGetter_(func, state.object_);
+    }
+    stack[stack.length - 1].value = value;
+  }
+};
+Interpreter.prototype["stepNewExpression"] = Interpreter.prototype["stepCallExpression"];
+Interpreter.prototype["stepObjectExpression"] = function (stack, state, node) {
+  var n = state.n_ || 0;
+  var property = node.properties[n];
+  if (!state.object_) {
+    state.object_ = this.createObjectProto(this.OBJECT_PROTO);
+    state.properties_ = Object.create(null);
+  } else {
+    var propName = state.destinationName;
+    if (!state.properties_[propName]) {
+      state.properties_[propName] = {};
+    }
+    state.properties_[propName][property.kind] = state.value;
+    state.n_ = ++n;
+    property = node.properties[n];
+  }
+  if (property) {
+    var key = property.key;
+    if (key.type === "Identifier") {
+      var propName = key.name;
+    } else if (key.type === "Literal") {
+      var propName = key.value;
+    } else {
+      throw SyntaxError("Unknown object structure: " + key.type);
+    }
+    state.destinationName = propName;
+    return new Interpreter.State(property.value, state.scope);
+  }
+  for (var key in state.properties_) {
+    var kinds = state.properties_[key];
+    if ("get" in kinds || "set" in kinds) {
+      var descriptor = {
+        configurable: true,
+        enumerable: true,
+        get: kinds["get"],
+        set: kinds["set"]
+      };
+      this.setProperty(state.object_, key, Interpreter.VALUE_IN_DESCRIPTOR, descriptor);
+    } else {
+      this.setProperty(state.object_, key, kinds["init"]);
+    }
+  }
+  stack.pop();
+  stack[stack.length - 1].value = state.object_;
+};
+Interpreter.prototype["stepProgram"] = function (stack, state, node) {
+  var expression = node.body.shift();
+  if (expression) {
+    state.done = false;
+    return new Interpreter.State(expression, state.scope);
+  }
+  state.done = true;
+};
+Interpreter.prototype["stepReturnStatement"] = function (stack, state, node) {
+  if (node.argument && !state.done_) {
+    state.done_ = true;
+    return new Interpreter.State(node.argument, state.scope);
+  }
+  this.unwind(Interpreter.Completion.RETURN, state.value, void 0);
+};
+Interpreter.prototype["stepSequenceExpression"] = function (stack, state, node) {
+  var n = state.n_ || 0;
+  var expression = node.expressions[n];
+  if (expression) {
+    state.n_ = n + 1;
+    return new Interpreter.State(expression, state.scope);
+  }
+  stack.pop();
+  stack[stack.length - 1].value = state.value;
+};
+Interpreter.prototype["stepSwitchStatement"] = function (stack, state, node) {
+  if (!state.test_) {
+    state.test_ = 1;
+    return new Interpreter.State(node.discriminant, state.scope);
+  }
+  if (state.test_ === 1) {
+    state.test_ = 2;
+    state.switchValue_ = state.value;
+    state.defaultCase_ = -1;
+  }
+  while (true) {
+    var index = state.index_ || 0;
+    var switchCase = node.cases[index];
+    if (!state.matched_ && switchCase && !switchCase.test) {
+      state.defaultCase_ = index;
+      state.index_ = index + 1;
+      continue;
+    }
+    if (!switchCase && !state.matched_ && state.defaultCase_ !== -1) {
+      state.matched_ = true;
+      state.index_ = state.defaultCase_;
+      continue;
+    }
+    if (switchCase) {
+      if (!state.matched_ && !state.tested_ && switchCase.test) {
+        state.tested_ = true;
+        return new Interpreter.State(switchCase.test, state.scope);
+      }
+      if (state.matched_ || state.value === state.switchValue_) {
+        state.matched_ = true;
+        var n = state.n_ || 0;
+        if (switchCase.consequent[n]) {
+          state.isSwitch = true;
+          state.n_ = n + 1;
+          return new Interpreter.State(switchCase.consequent[n], state.scope);
+        }
+      }
+      state.tested_ = false;
+      state.n_ = 0;
+      state.index_ = index + 1;
+    } else {
+      stack.pop();
+      return;
+    }
+  }
+};
+Interpreter.prototype["stepThisExpression"] = function (stack, state, node) {
+  stack.pop();
+  stack[stack.length - 1].value = this.getValueFromScope("this");
+};
+Interpreter.prototype["stepThrowStatement"] = function (stack, state, node) {
+  if (!state.done_) {
+    state.done_ = true;
+    return new Interpreter.State(node.argument, state.scope);
+  } else {
+    this.throwException(state.value);
+  }
+};
+Interpreter.prototype["stepTryStatement"] = function (stack, state, node) {
+  if (!state.doneBlock_) {
+    state.doneBlock_ = true;
+    return new Interpreter.State(node.block, state.scope);
+  }
+  if (state.cv && state.cv.type === Interpreter.Completion.THROW && !state.doneHandler_ && node.handler) {
+    state.doneHandler_ = true;
+    var scope = this.createSpecialScope(state.scope);
+    this.setProperty(scope.object, node.handler.param.name, state.cv.value);
+    state.cv = void 0;
+    return new Interpreter.State(node.handler.body, scope);
+  }
+  if (!state.doneFinalizer_ && node.finalizer) {
+    state.doneFinalizer_ = true;
+    return new Interpreter.State(node.finalizer, state.scope);
+  }
+  stack.pop();
+  if (state.cv) {
+    this.unwind(state.cv.type, state.cv.value, state.cv.label);
+  }
+};
+Interpreter.prototype["stepUnaryExpression"] = function (stack, state, node) {
+  if (!state.done_) {
+    state.done_ = true;
+    var nextState = new Interpreter.State(node.argument, state.scope);
+    nextState.components = node.operator === "delete";
+    return nextState;
+  }
+  stack.pop();
+  var value = state.value;
+  switch (node.operator) {
+    case "-":
+      value = -value;
+      break;
+    case "+":
+      value = +value;
+      break;
+    case "!":
+      value = !value;
+      break;
+    case "~":
+      value = ~value;
+      break;
+    case "delete":
+      var result = true;
+      if (Array.isArray(value)) {
+        var obj = value[0];
+        if (obj === Interpreter.SCOPE_REFERENCE) {
+          obj = state.scope;
+        }
+        var name = String(value[1]);
+        try {
+          delete obj.properties[name];
+        } catch (_e) {
+          if (state.scope.strict) {
+            this.throwException(this.TYPE_ERROR, "Cannot delete property '" + name + "' of '" + obj + "'");
+          } else {
+            result = false;
+          }
+        }
+      }
+      value = result;
+      break;
+    case "typeof":
+      value = value && value.class === "Function" ? "function" : typeof value;
+      break;
+    case "void":
+      value = void 0;
+      break;
+    default:
+      throw SyntaxError("Unknown unary operator: " + node.operator);
+  }
+  stack[stack.length - 1].value = value;
+};
+Interpreter.prototype["stepUpdateExpression"] = function (stack, state, node) {
+  if (!state.doneLeft_) {
+    state.doneLeft_ = true;
+    var nextState = new Interpreter.State(node.argument, state.scope);
+    nextState.components = true;
+    return nextState;
+  }
+  if (!state.leftSide_) {
+    state.leftSide_ = state.value;
+  }
+  if (state.doneGetter_) {
+    state.leftValue_ = state.value;
+  }
+  if (!state.doneGetter_) {
+    var leftValue = this.getValue(state.leftSide_);
+    state.leftValue_ = leftValue;
+    if (this.getterStep_) {
+      state.doneGetter_ = true;
+      var func = leftValue;
+      return this.createGetter_(func, state.leftSide_);
+    }
+  }
+  if (state.doneSetter_) {
+    stack.pop();
+    stack[stack.length - 1].value = state.setterValue_;
+    return;
+  }
+  var leftValue = Number(state.leftValue_);
+  var changeValue;
+  if (node.operator === "++") {
+    changeValue = leftValue + 1;
+  } else if (node.operator === "--") {
+    changeValue = leftValue - 1;
+  } else {
+    throw SyntaxError("Unknown update expression: " + node.operator);
+  }
+  var returnValue = node.prefix ? changeValue : leftValue;
+  var setter = this.setValue(state.leftSide_, changeValue);
+  if (setter) {
+    state.doneSetter_ = true;
+    state.setterValue_ = returnValue;
+    return this.createSetter_(setter, state.leftSide_, changeValue);
+  }
+  stack.pop();
+  stack[stack.length - 1].value = returnValue;
+};
+Interpreter.prototype["stepVariableDeclaration"] = function (stack, state, node) {
+  var declarations = node.declarations;
+  var n = state.n_ || 0;
+  var declarationNode = declarations[n];
+  if (state.init_ && declarationNode) {
+    this.setValueToScope(declarationNode.id.name, state.value);
+    state.init_ = false;
+    declarationNode = declarations[++n];
+  }
+  while (declarationNode) {
+    if (declarationNode.init) {
+      state.n_ = n;
+      state.init_ = true;
+      state.destinationName = declarationNode.id.name;
+      return new Interpreter.State(declarationNode.init, state.scope);
+    }
+    declarationNode = declarations[++n];
+  }
+  stack.pop();
+};
+Interpreter.prototype["stepWithStatement"] = function (stack, state, node) {
+  if (!state.doneObject_) {
+    state.doneObject_ = true;
+    return new Interpreter.State(node.object, state.scope);
+  }
+  stack.pop();
+  var scope = this.createSpecialScope(state.scope, state.value);
+  return new Interpreter.State(node.body, scope);
+};
+Interpreter.prototype["stepWhileStatement"] = Interpreter.prototype["stepDoWhileStatement"];
+Interpreter.nativeGlobal["Interpreter"] = Interpreter;
+Interpreter.prototype["step"] = Interpreter.prototype.step;
+Interpreter.prototype["run"] = Interpreter.prototype.run;
+Interpreter.prototype["appendCode"] = Interpreter.prototype.appendCode;
+Interpreter.prototype["createObject"] = Interpreter.prototype.createObject;
+Interpreter.prototype["createObjectProto"] = Interpreter.prototype.createObjectProto;
+Interpreter.prototype["createAsyncFunction"] = Interpreter.prototype.createAsyncFunction;
+Interpreter.prototype["createNativeFunction"] = Interpreter.prototype.createNativeFunction;
+Interpreter.prototype["getProperty"] = Interpreter.prototype.getProperty;
+Interpreter.prototype["setProperty"] = Interpreter.prototype.setProperty;
+Interpreter.prototype["nativeToPseudo"] = Interpreter.prototype.nativeToPseudo;
+Interpreter.prototype["pseudoToNative"] = Interpreter.prototype.pseudoToNative;
+Interpreter.prototype["getGlobalScope"] = Interpreter.prototype.getGlobalScope;
+Interpreter.prototype["getStateStack"] = Interpreter.prototype.getStateStack;
+Interpreter.prototype["setStateStack"] = Interpreter.prototype.setStateStack;
+Interpreter["VALUE_IN_DESCRIPTOR"] = Interpreter.VALUE_IN_DESCRIPTOR;
+import { parse } from "acorn";
+Interpreter.nativeGlobal.acornParse = parse;
+var stdin_default = Interpreter;
+export { stdin_default as default }