@workglow/javascript 0.2.28

package/dist/task.js

@@ -0,0 +1,4593 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/task/JavaScriptTask.ts
+import {
+  CreateWorkflow,
+  Entitlements,
+  Task,
+  TaskConfigSchema,
+  TaskInvalidInputError,
+  Workflow
+} from "@workglow/task-graph";
+
+// src/task/acorn.js
+var options;
+var input = "";
+var inputLen;
+var sourceFile;
+var parse = function(inpt, opts) {
+  input = String(inpt);
+  inputLen = input.length;
+  setOptions(opts);
+  initTokenState();
+  return parseTopLevel(options.program);
+};
+var defaultOptions = {
+  strictSemicolons: false,
+  allowTrailingCommas: true,
+  forbidReserved: false,
+  allowReturnOutsideFunction: false,
+  locations: false,
+  onComment: null,
+  ranges: false,
+  program: null,
+  sourceFile: null,
+  directSourceFile: null
+};
+function setOptions(opts) {
+  options = opts || {};
+  for (var opt in defaultOptions) {
+    if (!Object.prototype.hasOwnProperty.call(options, opt)) {
+      options[opt] = defaultOptions[opt];
+    }
+  }
+  sourceFile = options.sourceFile;
+}
+var getLineInfo = function(input2, offset) {
+  for (var line = 1, cur = 0;; ) {
+    lineBreak.lastIndex = cur;
+    var match = lineBreak.exec(input2);
+    if (match && match.index < offset) {
+      ++line;
+      cur = match.index + match[0].length;
+    } else {
+      break;
+    }
+  }
+  return { line, column: offset - cur };
+};
+var tokPos = 0;
+var tokStart = 0;
+var tokEnd = 0;
+var tokStartLoc;
+var tokEndLoc;
+var tokType;
+var tokVal;
+var tokRegexpAllowed;
+var tokCurLine;
+var tokLineStart;
+var lastStart = 0;
+var lastEnd = 0;
+var lastEndLoc;
+var inFunction;
+var labels;
+var strict;
+function raise(pos, message) {
+  var loc = getLineInfo(input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos;
+  err.loc = loc;
+  err.raisedAt = tokPos;
+  throw err;
+}
+var empty = [];
+var _num = { type: "num" };
+var _regexp = { type: "regexp" };
+var _string = { type: "string" };
+var _name = { type: "name" };
+var _eof = { type: "eof" };
+var _break = { keyword: "break" };
+var _case = { keyword: "case", beforeExpr: true };
+var _catch = { keyword: "catch" };
+var _continue = { keyword: "continue" };
+var _debugger = { keyword: "debugger" };
+var _default = { keyword: "default" };
+var _do = { keyword: "do", isLoop: true };
+var _else = { keyword: "else", beforeExpr: true };
+var _finally = { keyword: "finally" };
+var _for = { keyword: "for", isLoop: true };
+var _function = { keyword: "function" };
+var _if = { keyword: "if" };
+var _return = { keyword: "return", beforeExpr: true };
+var _switch = { keyword: "switch" };
+var _throw = { keyword: "throw", beforeExpr: true };
+var _try = { keyword: "try" };
+var _var = { keyword: "var" };
+var _while = { keyword: "while", isLoop: true };
+var _with = { keyword: "with" };
+var _new = { keyword: "new", beforeExpr: true };
+var _this = { keyword: "this" };
+var _null = { keyword: "null", atomValue: null };
+var _true = { keyword: "true", atomValue: true };
+var _false = { keyword: "false", atomValue: false };
+var _in = { keyword: "in", binop: 7, beforeExpr: true };
+var keywordTypes = {
+  break: _break,
+  case: _case,
+  catch: _catch,
+  continue: _continue,
+  debugger: _debugger,
+  default: _default,
+  do: _do,
+  else: _else,
+  finally: _finally,
+  for: _for,
+  function: _function,
+  if: _if,
+  return: _return,
+  switch: _switch,
+  throw: _throw,
+  try: _try,
+  var: _var,
+  while: _while,
+  with: _with,
+  null: _null,
+  true: _true,
+  false: _false,
+  new: _new,
+  in: _in,
+  instanceof: { keyword: "instanceof", binop: 7, beforeExpr: true },
+  this: _this,
+  typeof: { keyword: "typeof", prefix: true, beforeExpr: true },
+  void: { keyword: "void", prefix: true, beforeExpr: true },
+  delete: { keyword: "delete", prefix: true, beforeExpr: true }
+};
+var _bracketL = { type: "[", beforeExpr: true };
+var _bracketR = { type: "]" };
+var _braceL = { type: "{", beforeExpr: true };
+var _braceR = { type: "}" };
+var _parenL = { type: "(", beforeExpr: true };
+var _parenR = { type: ")" };
+var _comma = { type: ",", beforeExpr: true };
+var _semi = { type: ";", beforeExpr: true };
+var _colon = { type: ":", beforeExpr: true };
+var _dot = { type: "." };
+var _question = { type: "?", beforeExpr: true };
+var _slash = { binop: 10, beforeExpr: true };
+var _eq = { isAssign: true, beforeExpr: true };
+var _assign = { isAssign: true, beforeExpr: true };
+var _incDec = { postfix: true, prefix: true, isUpdate: true };
+var _prefix = { prefix: true, beforeExpr: true };
+var _logicalOR = { binop: 1, beforeExpr: true };
+var _logicalAND = { binop: 2, beforeExpr: true };
+var _bitwiseOR = { binop: 3, beforeExpr: true };
+var _bitwiseXOR = { binop: 4, beforeExpr: true };
+var _bitwiseAND = { binop: 5, beforeExpr: true };
+var _equality = { binop: 6, beforeExpr: true };
+var _relational = { binop: 7, beforeExpr: true };
+var _bitShift = { binop: 8, beforeExpr: true };
+var _plusMin = { binop: 9, prefix: true, beforeExpr: true };
+var _multiplyModulo = { binop: 10, beforeExpr: true };
+function makePredicate(words) {
+  var wordList = words.split(" ");
+  var set = Object.create(null);
+  for (var i = 0;i < wordList.length; i++) {
+    set[wordList[i]] = true;
+  }
+  return function(str) {
+    return set[str] || false;
+  };
+}
+var isReservedWord5 = makePredicate("class enum extends super const export import");
+var isStrictReservedWord = makePredicate("implements interface var package private protected public static yield");
+var isStrictBadIdWord = makePredicate("eval arguments");
+var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+var nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԧԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠࢢ-ࢬऄ-हऽॐक़-ॡॱ-ॷॹ-ॿঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-ళవ-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤜᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ々-〇〡-〩〱-〵〸-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚗꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꪀ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
+var nonASCIIidentifierChars = "̀-ͯ҃-֑҇-ׇֽֿׁׂׅׄؐ-ؚؠ-ىٲ-ۓۧ-ۨۻ-ۼܰ-݊ࠀ-ࠔࠛ-ࠣࠥ-ࠧࠩ-࠭ࡀ-ࡗࣤ-ࣾऀ-ःऺ-़ा-ॏ॑-ॗॢ-ॣ०-९ঁ-ঃ়া-ৄেৈৗয়-ৠਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢ-ૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୟ-ୠ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఁ-ఃె-ైొ-్ౕౖౢ-ౣ౦-౯ಂಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢ-ೣ೦-೯ംഃെ-ൈൗൢ-ൣ൦-൯ංඃ්ා-ුූෘ-ෟෲෳิ-ฺเ-ๅ๐-๙ິ-ູ່-ໍ໐-໙༘༙༠-༩༹༵༷ཁ-ཇཱ-྄྆-྇ྍ-ྗྙ-ྼ࿆က-ဩ၀-၉ၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟ᜎ-ᜐᜠ-ᜰᝀ-ᝐᝲᝳក-ឲ៝០-៩᠋-᠍᠐-᠙ᤠ-ᤫᤰ-᤻ᥑ-ᥭᦰ-ᧀᧈ-ᧉ᧐-᧙ᨀ-ᨕᨠ-ᩓ᩠-᩿᩼-᪉᪐-᪙ᭆ-ᭋ᭐-᭙᭫-᭳᮰-᮹᯦-᯳ᰀ-ᰢ᱀-᱉ᱛ-ᱽ᳐-᳒ᴀ-ᶾḁ-ἕ‌‍‿⁀⁔⃐-⃥⃜⃡-⃰ⶁ-ⶖⷠ-ⷿ〡-〨゙゚Ꙁ-ꙭꙴ-꙽ꚟ꛰-꛱ꟸ-ꠀ꠆ꠋꠣ-ꠧꢀ-ꢁꢴ-꣄꣐-꣙ꣳ-ꣷ꤀-꤉ꤦ-꤭ꤰ-ꥅꦀ-ꦃ꦳-꧀ꨀ-ꨧꩀ-ꩁꩌ-ꩍ꩐-꩙ꩻꫠ-ꫩꫲ-ꫳꯀ-ꯡ꯬꯭꯰-꯹ﬠ-ﬨ︀-️︠-︦︳︴﹍-﹏０-９＿";
+var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+var newline = /[\n\r\u2028\u2029]/;
+var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+var isIdentifierStart = function(code) {
+  if (code < 65)
+    return code === 36;
+  if (code < 91)
+    return true;
+  if (code < 97)
+    return code === 95;
+  if (code < 123)
+    return true;
+  return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
+};
+var isIdentifierChar = function(code) {
+  if (code < 48)
+    return code === 36;
+  if (code < 58)
+    return true;
+  if (code < 65)
+    return false;
+  if (code < 91)
+    return true;
+  if (code < 97)
+    return code === 95;
+  if (code < 123)
+    return true;
+  return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
+};
+function line_loc_t() {
+  this.line = tokCurLine;
+  this.column = tokPos - tokLineStart;
+}
+function initTokenState() {
+  tokCurLine = 1;
+  tokPos = tokLineStart = 0;
+  tokRegexpAllowed = true;
+  skipSpace();
+}
+function finishToken(type, val) {
+  tokEnd = tokPos;
+  if (options.locations) {
+    tokEndLoc = new line_loc_t;
+  }
+  tokType = type;
+  skipSpace();
+  tokVal = val;
+  tokRegexpAllowed = type.beforeExpr;
+}
+function skipBlockComment() {
+  var startLoc = options.onComment && options.locations && new line_loc_t;
+  var start = tokPos;
+  var end = input.indexOf("*/", tokPos += 2);
+  if (end === -1) {
+    raise(tokPos - 2, "Unterminated comment");
+  }
+  tokPos = end + 2;
+  if (options.locations) {
+    lineBreak.lastIndex = start;
+    var match;
+    while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+      ++tokCurLine;
+      tokLineStart = match.index + match[0].length;
+    }
+  }
+  if (options.onComment) {
+    options.onComment(true, input.slice(start + 2, end), start, tokPos, startLoc, options.locations && new line_loc_t);
+  }
+}
+function skipLineComment() {
+  var start = tokPos;
+  var startLoc = options.onComment && options.locations && new line_loc_t;
+  var ch = input.charCodeAt(tokPos += 2);
+  while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+    ++tokPos;
+    ch = input.charCodeAt(tokPos);
+  }
+  if (options.onComment) {
+    options.onComment(false, input.slice(start + 2, tokPos), start, tokPos, startLoc, options.locations && new line_loc_t);
+  }
+}
+function skipSpace() {
+  while (tokPos < inputLen) {
+    var ch = input.charCodeAt(tokPos);
+    if (ch === 32) {
+      ++tokPos;
+    } else if (ch === 13) {
+      ++tokPos;
+      var next = input.charCodeAt(tokPos);
+      if (next === 10) {
+        ++tokPos;
+      }
+      if (options.locations) {
+        ++tokCurLine;
+        tokLineStart = tokPos;
+      }
+    } else if (ch === 10 || ch === 8232 || ch === 8233) {
+      ++tokPos;
+      if (options.locations) {
+        ++tokCurLine;
+        tokLineStart = tokPos;
+      }
+    } else if (ch > 8 && ch < 14) {
+      ++tokPos;
+    } else if (ch === 47) {
+      var next = input.charCodeAt(tokPos + 1);
+      if (next === 42) {
+        skipBlockComment();
+      } else if (next === 47) {
+        skipLineComment();
+      } else
+        break;
+    } else if (ch === 160) {
+      ++tokPos;
+    } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+      ++tokPos;
+    } else {
+      break;
+    }
+  }
+}
+function readToken_dot() {
+  var next = input.charCodeAt(tokPos + 1);
+  if (next >= 48 && next <= 57) {
+    readNumber(true);
+  } else {
+    ++tokPos;
+    finishToken(_dot);
+  }
+}
+function readToken_slash() {
+  var next = input.charCodeAt(tokPos + 1);
+  if (tokRegexpAllowed) {
+    ++tokPos;
+    readRegexp();
+  } else if (next === 61) {
+    finishOp(_assign, 2);
+  } else {
+    finishOp(_slash, 1);
+  }
+}
+function readToken_mult_modulo() {
+  var next = input.charCodeAt(tokPos + 1);
+  if (next === 61) {
+    finishOp(_assign, 2);
+  } else {
+    finishOp(_multiplyModulo, 1);
+  }
+}
+function readToken_pipe_amp(code) {
+  var next = input.charCodeAt(tokPos + 1);
+  if (next === code) {
+    finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+  } else if (next === 61) {
+    finishOp(_assign, 2);
+  } else {
+    finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+}
+function readToken_caret() {
+  var next = input.charCodeAt(tokPos + 1);
+  if (next === 61) {
+    finishOp(_assign, 2);
+  } else {
+    finishOp(_bitwiseXOR, 1);
+  }
+}
+function readToken_plus_min(code) {
+  var next = input.charCodeAt(tokPos + 1);
+  if (next === code) {
+    if (next === 45 && input.charCodeAt(tokPos + 2) === 62 && newline.test(input.slice(lastEnd, tokPos))) {
+      tokPos += 3;
+      skipLineComment();
+      skipSpace();
+      readToken();
+      return;
+    }
+    finishOp(_incDec, 2);
+  } else if (next === 61) {
+    finishOp(_assign, 2);
+  } else {
+    finishOp(_plusMin, 1);
+  }
+}
+function readToken_lt_gt(code) {
+  var next = input.charCodeAt(tokPos + 1);
+  var size = 1;
+  if (next === code) {
+    size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+    if (input.charCodeAt(tokPos + size) === 61) {
+      finishOp(_assign, size + 1);
+    } else {
+      finishOp(_bitShift, size);
+    }
+    return;
+  }
+  if (next === 33 && code === 60 && input.charCodeAt(tokPos + 2) === 45 && input.charCodeAt(tokPos + 3) === 45) {
+    tokPos += 4;
+    skipLineComment();
+    skipSpace();
+    readToken();
+    return;
+  }
+  if (next === 61) {
+    size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+  }
+  finishOp(_relational, size);
+}
+function readToken_eq_excl(code) {
+  var next = input.charCodeAt(tokPos + 1);
+  if (next === 61) {
+    finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+  } else {
+    finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+}
+function getTokenFromCode(code) {
+  switch (code) {
+    case 46:
+      return readToken_dot();
+    case 40:
+      ++tokPos;
+      return finishToken(_parenL);
+    case 41:
+      ++tokPos;
+      return finishToken(_parenR);
+    case 59:
+      ++tokPos;
+      return finishToken(_semi);
+    case 44:
+      ++tokPos;
+      return finishToken(_comma);
+    case 91:
+      ++tokPos;
+      return finishToken(_bracketL);
+    case 93:
+      ++tokPos;
+      return finishToken(_bracketR);
+    case 123:
+      ++tokPos;
+      return finishToken(_braceL);
+    case 125:
+      ++tokPos;
+      return finishToken(_braceR);
+    case 58:
+      ++tokPos;
+      return finishToken(_colon);
+    case 63:
+      ++tokPos;
+      return finishToken(_question);
+    case 48:
+      var next = input.charCodeAt(tokPos + 1);
+      if (next === 120 || next === 88)
+        return readHexNumber();
+    case 49:
+    case 50:
+    case 51:
+    case 52:
+    case 53:
+    case 54:
+    case 55:
+    case 56:
+    case 57:
+      return readNumber(false);
+    case 34:
+    case 39:
+      return readString(code);
+    case 47:
+      return readToken_slash();
+    case 37:
+    case 42:
+      return readToken_mult_modulo();
+    case 124:
+    case 38:
+      return readToken_pipe_amp(code);
+    case 94:
+      return readToken_caret();
+    case 43:
+    case 45:
+      return readToken_plus_min(code);
+    case 60:
+    case 62:
+      return readToken_lt_gt(code);
+    case 61:
+    case 33:
+      return readToken_eq_excl(code);
+    case 126:
+      return finishOp(_prefix, 1);
+  }
+  return false;
+}
+function readToken(forceRegexp) {
+  if (!forceRegexp) {
+    tokStart = tokPos;
+  } else {
+    tokPos = tokStart + 1;
+  }
+  if (options.locations) {
+    tokStartLoc = new line_loc_t;
+  }
+  if (forceRegexp)
+    return readRegexp();
+  if (tokPos >= inputLen)
+    return finishToken(_eof);
+  var code = input.charCodeAt(tokPos);
+  if (isIdentifierStart(code) || code === 92) {
+    return readWord();
+  }
+  var tok = getTokenFromCode(code);
+  if (tok === false) {
+    var ch = String.fromCharCode(code);
+    if (ch === "\\" || nonASCIIidentifierStart.test(ch)) {
+      return readWord();
+    }
+    raise(tokPos, "Unexpected character '" + ch + "'");
+  }
+}
+function finishOp(type, size) {
+  var str = input.slice(tokPos, tokPos + size);
+  tokPos += size;
+  finishToken(type, str);
+}
+function readRegexp() {
+  var escaped;
+  var inClass;
+  var start = tokPos;
+  for (;; ) {
+    if (tokPos >= inputLen)
+      raise(start, "Unterminated regexp");
+    var ch = input.charAt(tokPos);
+    if (newline.test(ch))
+      raise(start, "Unterminated regexp");
+    if (!escaped) {
+      if (ch === "[") {
+        inClass = true;
+      } else if (ch === "]" && inClass) {
+        inClass = false;
+      } else if (ch === "/" && !inClass) {
+        break;
+      }
+      escaped = ch === "\\";
+    } else
+      escaped = false;
+    ++tokPos;
+  }
+  var content = input.slice(start, tokPos);
+  ++tokPos;
+  var mods = readWord1();
+  if (mods && !/^[gmi]*$/.test(mods)) {
+    raise(start, "Invalid regexp flag");
+  }
+  try {
+    var value = new RegExp(content, mods);
+  } catch (e) {
+    if (e instanceof SyntaxError)
+      raise(start, e.message);
+    throw e;
+  }
+  finishToken(_regexp, value);
+}
+function readInt(radix, len) {
+  var start = tokPos;
+  var total = 0;
+  var e = len === undefined ? Infinity : len;
+  for (var i = 0;i < e; ++i) {
+    var code = input.charCodeAt(tokPos), val;
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (code >= 48 && code <= 57) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix)
+      break;
+    ++tokPos;
+    total = total * radix + val;
+  }
+  if (tokPos === start || len !== undefined && tokPos - start !== len) {
+    return null;
+  }
+  return total;
+}
+function readHexNumber() {
+  tokPos += 2;
+  var val = readInt(16);
+  if (val === null) {
+    raise(tokStart + 2, "Expected hexadecimal number");
+  }
+  if (isIdentifierStart(input.charCodeAt(tokPos))) {
+    raise(tokPos, "Identifier directly after number");
+  }
+  finishToken(_num, val);
+}
+function readNumber(startsWithDot) {
+  var start = tokPos;
+  var isFloat = false;
+  var octal = input.charCodeAt(tokPos) === 48;
+  if (!startsWithDot && readInt(10) === null) {
+    raise(start, "Invalid number");
+  }
+  if (input.charCodeAt(tokPos) === 46) {
+    ++tokPos;
+    readInt(10);
+    isFloat = true;
+  }
+  var next = input.charCodeAt(tokPos);
+  if (next === 69 || next === 101) {
+    next = input.charCodeAt(++tokPos);
+    if (next === 43 || next === 45) {
+      ++tokPos;
+    }
+    if (readInt(10) === null) {
+      raise(start, "Invalid number");
+    }
+    isFloat = true;
+  }
+  if (isIdentifierStart(input.charCodeAt(tokPos))) {
+    raise(tokPos, "Identifier directly after number");
+  }
+  var str = input.slice(start, tokPos);
+  var val;
+  if (isFloat) {
+    val = parseFloat(str);
+  } else if (!octal || str.length === 1) {
+    val = parseInt(str, 10);
+  } else if (/[89]/.test(str) || strict) {
+    raise(start, "Invalid number");
+  } else {
+    val = parseInt(str, 8);
+  }
+  finishToken(_num, val);
+}
+function readString(quote) {
+  tokPos++;
+  var out = "";
+  for (;; ) {
+    if (tokPos >= inputLen)
+      raise(tokStart, "Unterminated string constant");
+    var ch = input.charCodeAt(tokPos);
+    if (ch === quote) {
+      ++tokPos;
+      finishToken(_string, out);
+      return;
+    }
+    if (ch === 92) {
+      ch = input.charCodeAt(++tokPos);
+      var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+      if (octal) {
+        octal = octal[0];
+      }
+      while (octal && parseInt(octal, 8) > 255) {
+        octal = octal.slice(0, -1);
+      }
+      if (octal === "0") {
+        octal = null;
+      }
+      ++tokPos;
+      if (octal) {
+        if (strict)
+          raise(tokPos - 2, "Octal literal in strict mode");
+        out += String.fromCharCode(parseInt(octal, 8));
+        tokPos += octal.length - 1;
+      } else {
+        switch (ch) {
+          case 110:
+            out += `
+`;
+            break;
+          case 114:
+            out += "\r";
+            break;
+          case 120:
+            out += String.fromCharCode(readHexChar(2));
+            break;
+          case 117:
+            out += String.fromCharCode(readHexChar(4));
+            break;
+          case 85:
+            out += String.fromCharCode(readHexChar(8));
+            break;
+          case 116:
+            out += "\t";
+            break;
+          case 98:
+            out += "\b";
+            break;
+          case 118:
+            out += "\v";
+            break;
+          case 102:
+            out += "\f";
+            break;
+          case 48:
+            out += "\x00";
+            break;
+          case 13:
+            if (input.charCodeAt(tokPos) === 10) {
+              ++tokPos;
+            }
+          case 10:
+            if (options.locations) {
+              tokLineStart = tokPos;
+              ++tokCurLine;
+            }
+            break;
+          default:
+            out += String.fromCharCode(ch);
+            break;
+        }
+      }
+    } else {
+      if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) {
+        raise(tokStart, "Unterminated string constant");
+      }
+      out += String.fromCharCode(ch);
+      ++tokPos;
+    }
+  }
+}
+function readHexChar(len) {
+  var n = readInt(16, len);
+  if (n === null)
+    raise(tokStart, "Bad character escape sequence");
+  return n;
+}
+var containsEsc;
+function readWord1() {
+  containsEsc = false;
+  var word;
+  var first = true;
+  var start = tokPos;
+  for (;; ) {
+    var ch = input.charCodeAt(tokPos);
+    if (isIdentifierChar(ch)) {
+      if (containsEsc) {
+        word += input.charAt(tokPos);
+      }
+      ++tokPos;
+    } else if (ch === 92) {
+      if (!containsEsc) {
+        word = input.slice(start, tokPos);
+      }
+      containsEsc = true;
+      if (input.charCodeAt(++tokPos) !== 117) {
+        raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+      }
+      ++tokPos;
+      var esc = readHexChar(4);
+      var escStr = String.fromCharCode(esc);
+      if (!escStr)
+        raise(tokPos - 1, "Invalid Unicode escape");
+      if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc))) {
+        raise(tokPos - 4, "Invalid Unicode escape");
+      }
+      word += escStr;
+    } else {
+      break;
+    }
+    first = false;
+  }
+  return containsEsc ? word : input.slice(start, tokPos);
+}
+function readWord() {
+  var word = readWord1();
+  var type = _name;
+  if (!containsEsc && isKeyword(word)) {
+    type = keywordTypes[word];
+  }
+  finishToken(type, word);
+}
+function next() {
+  lastStart = tokStart;
+  lastEnd = tokEnd;
+  lastEndLoc = tokEndLoc;
+  readToken();
+}
+function setStrict(strct) {
+  strict = strct;
+  tokPos = tokStart;
+  if (options.locations) {
+    while (tokPos < tokLineStart) {
+      tokLineStart = input.lastIndexOf(`
+`, tokLineStart - 2) + 1;
+      --tokCurLine;
+    }
+  }
+  skipSpace();
+  readToken();
+}
+function node_t() {
+  this.type = null;
+  this.start = tokStart;
+  this.end = null;
+}
+function node_loc_t() {
+  this.start = tokStartLoc;
+  this.end = null;
+  if (sourceFile) {
+    this.source = sourceFile;
+  }
+}
+function startNode() {
+  var node = new node_t;
+  if (options.locations) {
+    node.loc = new node_loc_t;
+  }
+  if (options.directSourceFile) {
+    node.sourceFile = options.directSourceFile;
+  }
+  if (options.ranges) {
+    node.range = [tokStart, 0];
+  }
+  return node;
+}
+function startNodeFrom(other) {
+  var node = new node_t;
+  node.start = other.start;
+  if (options.locations) {
+    node.loc = new node_loc_t;
+    node.loc.start = other.loc.start;
+  }
+  if (options.ranges) {
+    node.range = [other.range[0], 0];
+  }
+  return node;
+}
+function finishNode(node, type) {
+  node.type = type;
+  node.end = lastEnd;
+  if (options.locations) {
+    node.loc.end = lastEndLoc;
+  }
+  if (options.ranges) {
+    node.range[1] = lastEnd;
+  }
+  return node;
+}
+function isUseStrict(stmt) {
+  return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+}
+function eat(type) {
+  if (tokType === type) {
+    next();
+    return true;
+  }
+  return false;
+}
+function canInsertSemicolon() {
+  return !options.strictSemicolons && (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+}
+function semicolon() {
+  if (!eat(_semi) && !canInsertSemicolon()) {
+    unexpected();
+  }
+}
+function expect(type) {
+  if (tokType === type) {
+    next();
+  } else {
+    unexpected();
+  }
+}
+function unexpected() {
+  raise(tokStart, "Unexpected token");
+}
+function checkLVal(expr) {
+  if (expr.type !== "Identifier" && expr.type !== "MemberExpression") {
+    raise(expr.start, "Assigning to rvalue");
+  }
+  if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name)) {
+    raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+}
+function parseTopLevel(program) {
+  lastStart = lastEnd = tokPos;
+  if (options.locations) {
+    lastEndLoc = new line_loc_t;
+  }
+  inFunction = strict = false;
+  labels = [];
+  readToken();
+  var node = program || startNode();
+  var first = true;
+  if (!program) {
+    node.body = [];
+  }
+  while (tokType !== _eof) {
+    var stmt = parseStatement();
+    node.body.push(stmt);
+    if (first && isUseStrict(stmt)) {
+      setStrict(true);
+    }
+    first = false;
+  }
+  return finishNode(node, "Program");
+}
+var loopLabel = { kind: "loop" };
+var switchLabel = { kind: "switch" };
+function parseStatement() {
+  if (tokType === _slash || tokType === _assign && tokVal === "/=") {
+    readToken(true);
+  }
+  var starttype = tokType;
+  var node = startNode();
+  switch (starttype) {
+    case _break:
+    case _continue:
+      next();
+      var isBreak = starttype === _break;
+      if (eat(_semi) || canInsertSemicolon()) {
+        node.label = null;
+      } else if (tokType !== _name) {
+        unexpected();
+      } else {
+        node.label = parseIdent();
+        semicolon();
+      }
+      for (var i = 0;i < labels.length; ++i) {
+        var lab = labels[i];
+        if (node.label === null || lab.name === node.label.name) {
+          if (lab.kind !== null && (isBreak || lab.kind === "loop"))
+            break;
+          if (node.label && isBreak)
+            break;
+        }
+      }
+      if (i === labels.length) {
+        raise(node.start, "Unsyntactic " + starttype.keyword);
+      }
+      return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+    case _debugger:
+      next();
+      semicolon();
+      return finishNode(node, "DebuggerStatement");
+    case _do:
+      next();
+      labels.push(loopLabel);
+      node.body = parseStatement();
+      labels.pop();
+      expect(_while);
+      node.test = parseParenExpression();
+      semicolon();
+      return finishNode(node, "DoWhileStatement");
+    case _for:
+      next();
+      labels.push(loopLabel);
+      expect(_parenL);
+      if (tokType === _semi)
+        return parseFor(node, null);
+      if (tokType === _var) {
+        var init = startNode();
+        next();
+        parseVar(init, true);
+        finishNode(init, "VariableDeclaration");
+        if (init.declarations.length === 1 && eat(_in))
+          return parseForIn(node, init);
+        return parseFor(node, init);
+      }
+      var init = parseExpression(false, true);
+      if (eat(_in)) {
+        checkLVal(init);
+        return parseForIn(node, init);
+      }
+      return parseFor(node, init);
+    case _function:
+      next();
+      return parseFunction(node, true);
+    case _if:
+      next();
+      node.test = parseParenExpression();
+      node.consequent = parseStatement();
+      node.alternate = eat(_else) ? parseStatement() : null;
+      return finishNode(node, "IfStatement");
+    case _return:
+      if (!inFunction && !options.allowReturnOutsideFunction) {
+        raise(tokStart, "'return' outside of function");
+      }
+      next();
+      if (eat(_semi) || canInsertSemicolon()) {
+        node.argument = null;
+      } else {
+        node.argument = parseExpression();
+        semicolon();
+      }
+      return finishNode(node, "ReturnStatement");
+    case _switch:
+      next();
+      node.discriminant = parseParenExpression();
+      node.cases = [];
+      expect(_braceL);
+      labels.push(switchLabel);
+      for (var cur, sawDefault;tokType !== _braceR; ) {
+        if (tokType === _case || tokType === _default) {
+          var isCase = tokType === _case;
+          if (cur) {
+            finishNode(cur, "SwitchCase");
+          }
+          node.cases.push(cur = startNode());
+          cur.consequent = [];
+          next();
+          if (isCase) {
+            cur.test = parseExpression();
+          } else {
+            if (sawDefault) {
+              raise(lastStart, "Multiple default clauses");
+            }
+            sawDefault = true;
+            cur.test = null;
+          }
+          expect(_colon);
+        } else {
+          if (!cur)
+            unexpected();
+          cur.consequent.push(parseStatement());
+        }
+      }
+      if (cur)
+        finishNode(cur, "SwitchCase");
+      next();
+      labels.pop();
+      return finishNode(node, "SwitchStatement");
+    case _throw:
+      next();
+      if (newline.test(input.slice(lastEnd, tokStart)))
+        raise(lastEnd, "Illegal newline after throw");
+      node.argument = parseExpression();
+      semicolon();
+      return finishNode(node, "ThrowStatement");
+    case _try:
+      next();
+      node.block = parseBlock();
+      node.handler = null;
+      if (tokType === _catch) {
+        var clause = startNode();
+        next();
+        expect(_parenL);
+        clause.param = parseIdent();
+        if (strict && isStrictBadIdWord(clause.param.name))
+          raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+        expect(_parenR);
+        clause.body = parseBlock();
+        node.handler = finishNode(clause, "CatchClause");
+      }
+      node.finalizer = eat(_finally) ? parseBlock() : null;
+      if (!node.handler && !node.finalizer)
+        raise(node.start, "Missing catch or finally clause");
+      return finishNode(node, "TryStatement");
+    case _var:
+      next();
+      parseVar(node);
+      semicolon();
+      return finishNode(node, "VariableDeclaration");
+    case _while:
+      next();
+      node.test = parseParenExpression();
+      labels.push(loopLabel);
+      node.body = parseStatement();
+      labels.pop();
+      return finishNode(node, "WhileStatement");
+    case _with:
+      if (strict)
+        raise(tokStart, "'with' in strict mode");
+      next();
+      node.object = parseParenExpression();
+      node.body = parseStatement();
+      return finishNode(node, "WithStatement");
+    case _braceL:
+      return parseBlock();
+    case _semi:
+      next();
+      return finishNode(node, "EmptyStatement");
+    default:
+      var maybeName = tokVal;
+      var expr = parseExpression();
+      if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+        for (var i = 0;i < labels.length; ++i) {
+          if (labels[i].name === maybeName) {
+            raise(expr.start, "Label '" + maybeName + "' is already declared");
+          }
+        }
+        var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+        labels.push({ name: maybeName, kind });
+        node.body = parseStatement();
+        labels.pop();
+        node.label = expr;
+        return finishNode(node, "LabeledStatement");
+      } else {
+        node.expression = expr;
+        semicolon();
+        return finishNode(node, "ExpressionStatement");
+      }
+  }
+}
+function parseParenExpression() {
+  expect(_parenL);
+  var val = parseExpression();
+  expect(_parenR);
+  return val;
+}
+function parseBlock(allowStrict) {
+  var node = startNode();
+  var first = true;
+  var strict2 = false;
+  var oldStrict;
+  node.body = [];
+  expect(_braceL);
+  while (!eat(_braceR)) {
+    var stmt = parseStatement();
+    node.body.push(stmt);
+    if (first && allowStrict && isUseStrict(stmt)) {
+      oldStrict = strict2;
+      setStrict(strict2 = true);
+    }
+    first = false;
+  }
+  if (strict2 && !oldStrict)
+    setStrict(false);
+  return finishNode(node, "BlockStatement");
+}
+function parseFor(node, init) {
+  node.init = init;
+  expect(_semi);
+  node.test = tokType === _semi ? null : parseExpression();
+  expect(_semi);
+  node.update = tokType === _parenR ? null : parseExpression();
+  expect(_parenR);
+  node.body = parseStatement();
+  labels.pop();
+  return finishNode(node, "ForStatement");
+}
+function parseForIn(node, init) {
+  node.left = init;
+  node.right = parseExpression();
+  expect(_parenR);
+  node.body = parseStatement();
+  labels.pop();
+  return finishNode(node, "ForInStatement");
+}
+function parseVar(node, noIn) {
+  node.declarations = [];
+  node.kind = "var";
+  for (;; ) {
+    var decl = startNode();
+    decl.id = parseIdent();
+    if (strict && isStrictBadIdWord(decl.id.name))
+      raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+    decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+    node.declarations.push(finishNode(decl, "VariableDeclarator"));
+    if (!eat(_comma))
+      break;
+  }
+}
+function parseExpression(noComma, noIn) {
+  var expr = parseMaybeAssign(noIn);
+  if (!noComma && tokType === _comma) {
+    var node = startNodeFrom(expr);
+    node.expressions = [expr];
+    while (eat(_comma))
+      node.expressions.push(parseMaybeAssign(noIn));
+    return finishNode(node, "SequenceExpression");
+  }
+  return expr;
+}
+function parseMaybeAssign(noIn) {
+  var left = parseMaybeConditional(noIn);
+  if (tokType.isAssign) {
+    var node = startNodeFrom(left);
+    node.operator = tokVal;
+    node.left = left;
+    next();
+    node.right = parseMaybeAssign(noIn);
+    checkLVal(left);
+    return finishNode(node, "AssignmentExpression");
+  }
+  return left;
+}
+function parseMaybeConditional(noIn) {
+  var expr = parseExprOps(noIn);
+  if (eat(_question)) {
+    var node = startNodeFrom(expr);
+    node.test = expr;
+    node.consequent = parseExpression(true);
+    expect(_colon);
+    node.alternate = parseExpression(true, noIn);
+    return finishNode(node, "ConditionalExpression");
+  }
+  return expr;
+}
+function parseExprOps(noIn) {
+  return parseExprOp(parseMaybeUnary(), -1, noIn);
+}
+function parseExprOp(left, minPrec, noIn) {
+  var prec = tokType.binop;
+  if (prec !== null && (!noIn || tokType !== _in)) {
+    if (prec > minPrec) {
+      var node = startNodeFrom(left);
+      node.left = left;
+      node.operator = tokVal;
+      var op = tokType;
+      next();
+      node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+      var exprNode = finishNode(node, op === _logicalOR || op === _logicalAND ? "LogicalExpression" : "BinaryExpression");
+      return parseExprOp(exprNode, minPrec, noIn);
+    }
+  }
+  return left;
+}
+function parseMaybeUnary() {
+  if (tokType.prefix) {
+    var node = startNode();
+    var update = tokType.isUpdate;
+    node.operator = tokVal;
+    node.prefix = true;
+    tokRegexpAllowed = true;
+    next();
+    node.argument = parseMaybeUnary();
+    if (update)
+      checkLVal(node.argument);
+    else if (strict && node.operator === "delete" && node.argument.type === "Identifier")
+      raise(node.start, "Deleting local variable in strict mode");
+    return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  }
+  var expr = parseExprSubscripts();
+  while (tokType.postfix && !canInsertSemicolon()) {
+    var node = startNodeFrom(expr);
+    node.operator = tokVal;
+    node.prefix = false;
+    node.argument = expr;
+    checkLVal(expr);
+    next();
+    expr = finishNode(node, "UpdateExpression");
+  }
+  return expr;
+}
+function parseExprSubscripts() {
+  return parseSubscripts(parseExprAtom());
+}
+function parseSubscripts(base, noCalls) {
+  var node;
+  if (eat(_dot)) {
+    node = startNodeFrom(base);
+    node.object = base;
+    node.property = parseIdent(true);
+    node.computed = false;
+    return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+  }
+  if (eat(_bracketL)) {
+    node = startNodeFrom(base);
+    node.object = base;
+    node.property = parseExpression();
+    node.computed = true;
+    expect(_bracketR);
+    return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+  }
+  if (!noCalls && eat(_parenL)) {
+    node = startNodeFrom(base);
+    node.callee = base;
+    node.arguments = parseExprList(_parenR, false);
+    return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+  }
+  return base;
+}
+function parseExprAtom() {
+  var node;
+  switch (tokType) {
+    case _this:
+      node = startNode();
+      next();
+      return finishNode(node, "ThisExpression");
+    case _name:
+      return parseIdent();
+    case _num:
+    case _string:
+    case _regexp:
+      node = startNode();
+      node.value = tokVal;
+      node.raw = input.slice(tokStart, tokEnd);
+      next();
+      return finishNode(node, "Literal");
+    case _null:
+    case _true:
+    case _false:
+      node = startNode();
+      node.value = tokType.atomValue;
+      node.raw = tokType.keyword;
+      next();
+      return finishNode(node, "Literal");
+    case _parenL:
+      var tokStartLoc1 = tokStartLoc;
+      var tokStart1 = tokStart;
+      next();
+      var val = parseExpression();
+      val.start = tokStart1;
+      val.end = tokEnd;
+      if (options.locations) {
+        val.loc.start = tokStartLoc1;
+        val.loc.end = tokEndLoc;
+      }
+      if (options.ranges) {
+        val.range = [tokStart1, tokEnd];
+      }
+      expect(_parenR);
+      return val;
+    case _bracketL:
+      node = startNode();
+      next();
+      node.elements = parseExprList(_bracketR, true, true);
+      return finishNode(node, "ArrayExpression");
+    case _braceL:
+      return parseObj();
+    case _function:
+      node = startNode();
+      next();
+      return parseFunction(node, false);
+    case _new:
+      return parseNew();
+  }
+  unexpected();
+}
+function parseNew() {
+  var node = startNode();
+  next();
+  node.callee = parseSubscripts(parseExprAtom(), true);
+  node.arguments = eat(_parenL) ? parseExprList(_parenR, false) : empty;
+  return finishNode(node, "NewExpression");
+}
+function parseObj() {
+  var node = startNode();
+  var first = true;
+  var sawGetSet = false;
+  node.properties = [];
+  next();
+  while (!eat(_braceR)) {
+    if (!first) {
+      expect(_comma);
+      if (options.allowTrailingCommas && eat(_braceR)) {
+        break;
+      }
+    } else {
+      first = false;
+    }
+    var prop = { key: parsePropertyName() };
+    var isGetSet = false;
+    var kind;
+    if (eat(_colon)) {
+      prop.value = parseExpression(true);
+      kind = prop.kind = "init";
+    } else if (prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set")) {
+      isGetSet = sawGetSet = true;
+      kind = prop.kind = prop.key.name;
+      prop.key = parsePropertyName();
+      if (tokType !== _parenL)
+        unexpected();
+      prop.value = parseFunction(startNode(), false);
+    } else {
+      unexpected();
+    }
+    if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+      for (var i = 0;i < node.properties.length; ++i) {
+        var other = node.properties[i];
+        if (other.key.name === prop.key.name) {
+          var conflict = kind === other.kind || isGetSet && other.kind === "init" || kind === "init" && (other.kind === "get" || other.kind === "set");
+          if (conflict && !strict && kind === "init" && other.kind === "init") {
+            conflict = false;
+          }
+          if (conflict) {
+            raise(prop.key.start, "Redefinition of property");
+          }
+        }
+      }
+    }
+    node.properties.push(prop);
+  }
+  return finishNode(node, "ObjectExpression");
+}
+function parsePropertyName() {
+  if (tokType === _num || tokType === _string) {
+    return parseExprAtom();
+  }
+  return parseIdent(true);
+}
+function parseFunction(node, isStatement) {
+  if (tokType === _name) {
+    node.id = parseIdent();
+  } else if (isStatement) {
+    unexpected();
+  } else {
+    node.id = null;
+  }
+  node.params = [];
+  var first = true;
+  expect(_parenL);
+  while (!eat(_parenR)) {
+    if (!first) {
+      expect(_comma);
+    } else {
+      first = false;
+    }
+    node.params.push(parseIdent());
+  }
+  var oldInFunc = inFunction;
+  var oldLabels = labels;
+  inFunction = true;
+  labels = [];
+  node.body = parseBlock(true);
+  inFunction = oldInFunc;
+  labels = oldLabels;
+  if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+    for (var i = node.id ? -1 : 0;i < node.params.length; ++i) {
+      var id = i < 0 ? node.id : node.params[i];
+      if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name)) {
+        raise(id.start, "Defining '" + id.name + "' in strict mode");
+      }
+      if (i >= 0) {
+        for (var j = 0;j < i; ++j) {
+          if (id.name === node.params[j].name) {
+            raise(id.start, "Argument name clash in strict mode");
+          }
+        }
+      }
+    }
+  }
+  return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+}
+function parseExprList(close, allowTrailingComma, allowEmpty) {
+  var elts = [];
+  var first = true;
+  while (!eat(close)) {
+    if (!first) {
+      expect(_comma);
+      if (allowTrailingComma && options.allowTrailingCommas && eat(close)) {
+        break;
+      }
+    } else {
+      first = false;
+    }
+    elts.push(allowEmpty && tokType === _comma ? null : parseExpression(true));
+  }
+  return elts;
+}
+function parseIdent(liberal) {
+  var node = startNode();
+  if (liberal && options.forbidReserved === "everywhere") {
+    liberal = false;
+  }
+  if (tokType === _name) {
+    if (!liberal && (options.forbidReserved && isReservedWord5(tokVal) || strict && isStrictReservedWord(tokVal)) && input.slice(tokStart, tokEnd).indexOf("\\") === -1) {
+      raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+    }
+    node.name = tokVal;
+  } else if (liberal && tokType.keyword) {
+    node.name = tokType.keyword;
+  } else {
+    unexpected();
+  }
+  tokRegexpAllowed = false;
+  next();
+  return finishNode(node, "Identifier");
+}
+
+// src/task/interpreter.js
+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.tasks = [];
+  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(`
+`), "polyfills");
+  this.polyfills_ = undefined;
+  Interpreter.stripLocations_(this.ast, undefined, undefined);
+  var state = new Interpreter.State(this.ast, this.globalScope);
+  state.done = false;
+  this.stateStack = [state];
+  this.run();
+  this.value = undefined;
+  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.Status = {
+  DONE: 0,
+  STEP: 1,
+  TASK: 2,
+  ASYNC: 3
+};
+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" ? null : 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"] = 1000;
+Interpreter.prototype["POLYFILL_TIMEOUT"] = 1000;
+Interpreter.prototype.getterStep_ = false;
+Interpreter.prototype.setterStep_ = false;
+Interpreter.prototype.appendCodeNumber_ = 0;
+Interpreter.prototype.taskCodeNumber_ = 0;
+Interpreter.prototype.parse_ = function(code, sourceFile2) {
+  var options2 = {};
+  for (var name in Interpreter.PARSE_OPTIONS) {
+    options2[name] = Interpreter.PARSE_OPTIONS[name];
+  }
+  options2.sourceFile = sourceFile2;
+  return parse(code, options2);
+};
+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 (this.paused_) {
+      return true;
+    } else if (!state || state.node.type === "Program" && state.done) {
+      if (!this.tasks.length) {
+        return false;
+      }
+      state = this.nextTask_();
+      if (!state) {
+        return true;
+      }
+    }
+    var node = state.node;
+    var oldInterpreterValue = Interpreter.currentInterpreter_;
+    Interpreter.currentInterpreter_ = this;
+    try {
+      var nextState = this.stepFunctions_[node.type](stack, state, node);
+    } catch (e) {
+      if (e !== Interpreter.STEP_ERROR) {
+        if (this.value !== e) {
+          this.value = undefined;
+        }
+        throw e;
+      }
+    } finally {
+      Interpreter.currentInterpreter_ = oldInterpreterValue;
+    }
+    if (nextState) {
+      stack.push(nextState);
+    }
+    if (this.getterStep_) {
+      this.value = undefined;
+      throw Error("Getter not supported in this context");
+    }
+    if (this.setterStep_) {
+      this.value = undefined;
+      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.getStatus = function() {
+  if (this.paused_) {
+    return Interpreter.Status["ASYNC"];
+  }
+  var stack = this.stateStack;
+  var state = stack[stack.length - 1];
+  if (state && (state.node.type !== "Program" || !state.done)) {
+    return Interpreter.Status["STEP"];
+  }
+  var task = this.tasks[0];
+  if (task) {
+    if (task.time > Date.now()) {
+      return Interpreter.Status["TASK"];
+    }
+    return Interpreter.Status["STEP"];
+  }
+  return Interpreter.Status["DONE"];
+};
+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", undefined, 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 wrapper;
+  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++) {
+    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);
+  }
+  wrapper = function setTimeout2(var_args) {
+    return thisInterpreter.createTask_(false, arguments);
+  };
+  this.setProperty(globalObject, "setTimeout", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function setInterval(var_args) {
+    return thisInterpreter.createTask_(true, arguments);
+  };
+  this.setProperty(globalObject, "setInterval", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function clearTimeout2(pid) {
+    thisInterpreter.deleteTask_(pid);
+  };
+  this.setProperty(globalObject, "clearTimeout", this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR);
+  wrapper = function clearInterval(pid) {
+    thisInterpreter.deleteTask_(pid);
+  };
+  this.setProperty(globalObject, "clearInterval", 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 !== undefined) {
+      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 === undefined || 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 === undefined || 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;
+    }
+    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, options2) {
+    locales = thisInterpreter.pseudoToNative(locales);
+    options2 = thisInterpreter.pseudoToNative(options2);
+    try {
+      return String(this).localeCompare(compareString, locales, options2);
+    } 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) : undefined;
+    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, options2) {
+    locales = locales ? thisInterpreter.pseudoToNative(locales) : undefined;
+    options2 = options2 ? thisInterpreter.pseudoToNative(options2) : undefined;
+    try {
+      return Number(this).toLocaleString(locales, options2);
+    } 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 === undefined && thisInterpreter.isa(pattern, thisInterpreter.REGEXP)) {
+        return pattern;
+      }
+      var rgx = thisInterpreter.createObjectProto(thisInterpreter.REGEXP_PROTO);
+    }
+    pattern = pattern === undefined ? "" : 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", undefined, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.REGEXP.properties["prototype"], "ignoreCase", undefined, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR);
+  this.setProperty(this.REGEXP.properties["prototype"], "multiline", undefined, 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 = undefined;
+    }
+    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 === undefined || !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 + `
+`;
+  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 + `)
+`;
+    } else {
+      stackString += "  at " + locString + `
+`;
+    }
+  }
+  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(`
+`)], { type: "application/javascript" });
+    this.createWorker.blob_ = blob;
+  }
+  return new Worker(URL.createObjectURL(blob));
+};
+Interpreter.prototype.vmCall = function(code, sandbox, nativeRegExp, callback) {
+  var options2 = { timeout: this["REGEXP_THREAD_TIMEOUT"] };
+  try {
+    return Interpreter.vm["runInNewContext"](code, sandbox, options2);
+  } 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 (true) {
+      try {
+        Interpreter.vm = __require("vm");
+      } catch (_e) {}
+      ok = !!Interpreter.vm;
+    } else {}
+  }
+  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 === undefined || 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 === undefined || 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;
+};
+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 === undefined || 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 strict2 = !this.stateStack || this.getScope().strict;
+  if (!(obj instanceof Interpreter.Object)) {
+    if (strict2) {
+      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 (strict2) {
+        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 (strict2) {
+      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 (strict2) {
+        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 (strict2) {
+          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 strict2 = false;
+  if (parentScope && parentScope.strict) {
+    strict2 = true;
+  } else {
+    var firstNode = node.body && node.body[0];
+    if (firstNode && firstNode.expression && firstNode.expression.type === "Literal" && firstNode.expression.value === "use strict") {
+      strict2 = true;
+    }
+  }
+  var object = this.createObjectProto(null);
+  var scope = new Interpreter.Scope(parentScope, strict2, 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;
+  }
+  this.throwException(this.REFERENCE_ERROR, name + " is not defined");
+};
+Interpreter.prototype.setValueToScope = function(name, value) {
+  var scope = this.getScope();
+  var strict2 = scope.strict;
+  while (scope && scope !== this.globalScope) {
+    if (name in scope.object.properties) {
+      try {
+        scope.object.properties[name] = value;
+      } catch (_e) {
+        if (strict2) {
+          this.throwException(this.TYPE_ERROR, "Cannot assign to read only variable '" + name + "'");
+        }
+      }
+      return;
+    }
+    scope = scope.parentScope;
+  }
+  if (scope === this.globalScope && (!strict2 || 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, undefined, 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 === undefined ? errorClass : opt_message;
+  }
+  if (opt_message === undefined || !(errorClass instanceof Interpreter.Object)) {
+    var error = errorClass;
+  } else {
+    var error = this.createObject(errorClass);
+    this.populateError(error, opt_message);
+  }
+  this.unwind(Interpreter.Completion.THROW, error, undefined);
+  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("Unsyntactic 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.createTask_ = function(isInterval, args) {
+  var parentState = this.stateStack[this.stateStack.length - 1];
+  var argsArray = Array.from(args);
+  var exec = argsArray.shift();
+  var delay = Math.max(Number(argsArray.shift() || 0), 0);
+  var node = this.newNode();
+  var scope, functionRef, ast;
+  if (exec instanceof Interpreter.Object && exec.class === "Function") {
+    functionRef = exec;
+    node.type = "CallExpression";
+    scope = parentState.scope;
+  } else {
+    try {
+      ast = this.parse_(String(exec), "taskCode" + this.taskCodeNumber_++);
+    } catch (e) {
+      this.throwException(this.SYNTAX_ERROR, "Invalid code: " + e.message);
+    }
+    node.type = "EvalProgram_";
+    node.body = ast.body;
+    var execNode = parentState.node.arguments[0];
+    var execStart = execNode ? execNode.start : undefined;
+    var execEnd = execNode ? execNode.end : undefined;
+    Interpreter.stripLocations_(node, execStart, execEnd);
+    scope = this.globalScope;
+    argsArray.length = 0;
+  }
+  var task = new Interpreter.Task(functionRef, argsArray, scope, node, isInterval ? delay : -1);
+  this.scheduleTask_(task, delay);
+  return task.pid;
+};
+Interpreter.prototype.scheduleTask_ = function(task, delay) {
+  task.time = Date.now() + delay;
+  this.tasks.push(task);
+  this.tasks.sort(function(a, b) {
+    return a.time - b.time;
+  });
+};
+Interpreter.prototype.deleteTask_ = function(pid) {
+  for (var i = 0;i < this.tasks.length; i++) {
+    if (this.tasks[i].pid == pid) {
+      this.tasks.splice(i, 1);
+      break;
+    }
+  }
+};
+Interpreter.prototype.nextTask_ = function() {
+  var task = this.tasks[0];
+  if (!task || task.time > Date.now()) {
+    return null;
+  }
+  this.tasks.shift();
+  if (task.interval >= 0) {
+    this.scheduleTask_(task, task.interval);
+  }
+  var state = new Interpreter.State(task.node, task.scope);
+  if (task.functionRef) {
+    state.doneCallee_ = 2;
+    state.funcThis_ = this.globalObject;
+    state.func_ = task.functionRef;
+    state.doneArgs_ = true;
+    state.arguments_ = task.argsArray;
+  }
+  return state;
+};
+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 === undefined || 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;
+
+class State {
+  constructor(node, scope) {
+    this.node = node;
+    this.scope = scope;
+  }
+}
+Interpreter.State = State;
+
+class Scope {
+  constructor(parentScope, strict2, object) {
+    this.parentScope = parentScope;
+    this.strict = strict2;
+    this.object = object;
+  }
+}
+Interpreter.Scope = Scope;
+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 = 1000;
+        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 === undefined || this.data === null || this.data instanceof RegExp) {
+    return this;
+  }
+  if (this.data instanceof Date) {
+    return this.data.valueOf();
+  }
+  return this.data;
+};
+Interpreter.Task = function(functionRef, argsArray, scope, node, interval) {
+  this.functionRef = functionRef;
+  this.argsArray = argsArray;
+  this.scope = scope;
+  this.node = node;
+  this.interval = interval;
+  this.pid = ++Interpreter.Task.pid;
+  this.time = 0;
+};
+Interpreter.Task.pid = 0;
+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, undefined, 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] : undefined;
+        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 = undefined;
+      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 = undefined;
+        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 = undefined;
+  }
+  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, undefined, label);
+};
+Interpreter.prototype["stepDebuggerStatement"] = function(stack, state, node) {
+  stack.pop();
+};
+Interpreter.prototype["stepDoWhileStatement"] = function(stack, state, node) {
+  if (node.type === "DoWhileStatement" && state.test_ === undefined) {
+    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 = undefined;
+    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_ === undefined) {
+    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 === undefined) {
+              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_ !== undefined) {
+          if (!state.props_) {
+            state.props_ = Object.getOwnPropertyNames(state.object_);
+          }
+          while (true) {
+            var prop = state.props_.shift();
+            if (prop === undefined) {
+              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_ = undefined;
+  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 labels2 = state.labels || [];
+  labels2.push(node.label.name);
+  var nextState = new Interpreter.State(node.body, state.scope);
+  nextState.labels = labels2;
+  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, undefined);
+};
+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 = undefined;
+    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 = undefined;
+      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["getStatus"] = Interpreter.prototype.getStatus;
+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;
+Interpreter["Status"] = Interpreter.Status;
+
+// src/task/JavaScriptTask.ts
+var isValidIdentifier = (key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+function runJavaScript(input2, configuredCode) {
+  const output = {};
+  const code = input2.javascript_code || configuredCode;
+  if (code) {
+    try {
+      const inputVariables = Object.keys(input2).filter((key) => key !== "javascript_code").filter(isValidIdentifier);
+      const inputVariablesString = inputVariables.map((key) => `var ${key} = ${JSON.stringify(input2[key])};`).join(`
+`);
+      const myInterpreter = new Interpreter(`${inputVariablesString} ${code}`);
+      myInterpreter.run();
+      output.output = myInterpreter.value;
+    } catch (e) {
+      throw new TaskInvalidInputError(`JavaScript execution failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return output;
+}
+var configSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"],
+    javascript_code: {
+      type: "string",
+      title: "Code",
+      minLength: 1,
+      description: "JavaScript code to execute",
+      format: "code:javascript"
+    }
+  },
+  additionalProperties: false
+};
+var inputSchema = {
+  type: "object",
+  properties: {
+    javascript_code: {
+      type: "string",
+      title: "Code",
+      minLength: 1,
+      description: "JavaScript code to execute",
+      format: "code:javascript"
+    }
+  },
+  required: ["javascript_code"],
+  additionalProperties: true
+};
+var outputSchema = {
+  type: "object",
+  properties: {
+    output: {
+      title: "Output",
+      description: "The output of the JavaScript code"
+    }
+  },
+  required: ["output"],
+  additionalProperties: false
+};
+
+class JavaScriptTask extends Task {
+  static type = "JavaScriptTask";
+  static category = "Utility";
+  static title = "JavaScript Interpreter";
+  static description = "Executes JavaScript code in a sandboxed interpreter environment";
+  static customizable = true;
+  static hasDynamicSchemas = true;
+  static entitlements() {
+    return {
+      entitlements: [
+        {
+          id: Entitlements.CODE_EXECUTION_JS,
+          reason: "Executes user-provided JavaScript code in a sandboxed interpreter"
+        }
+      ]
+    };
+  }
+  static configSchema() {
+    return configSchema;
+  }
+  static inputSchema() {
+    return inputSchema;
+  }
+  static outputSchema() {
+    return outputSchema;
+  }
+  inputSchema() {
+    if (this.config?.javascript_code) {
+      if (this.config.inputSchema) {
+        return this.config.inputSchema;
+      }
+      return {
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      };
+    }
+    return inputSchema;
+  }
+  async execute(input2) {
+    return runJavaScript(input2, this.config.javascript_code);
+  }
+  async executePreview(input2) {
+    return runJavaScript(input2, this.config.javascript_code);
+  }
+}
+var javaScript = (input2, config = {}) => {
+  return new JavaScriptTask(config).run(input2);
+};
+Workflow.prototype.javaScript = CreateWorkflow(JavaScriptTask);
+export {
+  javaScript,
+  JavaScriptTask
+};
+
+//# debugId=6FEE0CBA2077225564756E2164756E21