diff --git a/test/fixtures/babel.js b/test/fixtures/babel.js
new file mode 100644
index 0000000..add5feb
--- /dev/null
+++ b/test/fixtures/babel.js
@@ -0,0 +1,43557 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.babel=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (global){
+"use strict";
+
+var transform = module.exports = require("../transformation");
+
+transform.version = require("../../../package").version;
+
+transform.transform = transform;
+
+transform.run = function (code, opts) {
+  opts = opts || {};
+  opts.sourceMap = "inline";
+  return new Function(transform(code, opts).code)();
+};
+
+transform.load = function (url, callback, opts, hold) {
+  opts = opts || {};
+  opts.filename = opts.filename || url;
+
+  var xhr = global.ActiveXObject ? new global.ActiveXObject("Microsoft.XMLHTTP") : new global.XMLHttpRequest();
+  xhr.open("GET", url, true);
+  if ("overrideMimeType" in xhr) xhr.overrideMimeType("text/plain");
+
+  xhr.onreadystatechange = function () {
+    if (xhr.readyState !== 4) return;
+
+    var status = xhr.status;
+    if (status === 0 || status === 200) {
+      var param = [xhr.responseText, opts];
+      if (!hold) transform.run.apply(transform, param);
+      if (callback) callback(param);
+    } else {
+      throw new Error("Could not load " + url);
+    }
+  };
+
+  xhr.send(null);
+};
+
+var runScripts = function () {
+  var scripts = [];
+  var types   = ["text/ecmascript-6", "text/6to5", "text/babel", "module"];
+  var index   = 0;
+
+  var exec = function () {
+    var param = scripts[index];
+    if (param instanceof Array) {
+      transform.run.apply(transform, param);
+      index++;
+      exec();
+    }
+  };
+
+  var run = function (script, i) {
+    var opts = {};
+
+    if (script.src) {
+      transform.load(script.src, function (param) {
+        scripts[i] = param;
+        exec();
+      }, opts, true);
+    } else {
+      opts.filename = "embedded";
+      scripts[i] = [script.innerHTML, opts];
+    }
+  };
+
+  var _scripts = global.document .getElementsByTagName("script");
+
+  for (var i = 0; i < _scripts.length; ++i) {
+    var _script = _scripts[i];
+    if (types.indexOf(_script.type) >= 0) scripts.push(_script);
+  }
+
+  for (i in scripts) {
+    run(scripts[i], i);
+  }
+
+  exec();
+};
+
+if (global.addEventListener) {
+  global.addEventListener("DOMContentLoaded", runScripts, false);
+} else if (global.attachEvent) {
+  global.attachEvent("onload", runScripts);
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../../../package":338,"../transformation":41}],2:[function(require,module,exports){
+"use strict";
+
+module.exports = Buffer;
+
+var repeating = require("repeating");
+var trimRight = require("trim-right");
+var isBoolean = require("lodash/lang/isBoolean");
+var includes  = require("lodash/collection/includes");
+var isNumber  = require("lodash/lang/isNumber");
+
+function Buffer(position, format) {
+  this.position = position;
+  this._indent  = format.indent.base;
+  this.format   = format;
+  this.buf      = "";
+}
+
+Buffer.prototype.get = function () {
+  return trimRight(this.buf);
+};
+
+Buffer.prototype.getIndent = function () {
+  if (this.format.compact || this.format.concise) {
+    return "";
+  } else {
+    return repeating(this.format.indent.style, this._indent);
+  }
+};
+
+Buffer.prototype.indentSize = function () {
+  return this.getIndent().length;
+};
+
+Buffer.prototype.indent = function () {
+  this._indent++;
+};
+
+Buffer.prototype.dedent = function () {
+  this._indent--;
+};
+
+Buffer.prototype.semicolon = function () {
+  this.push(";");
+};
+
+Buffer.prototype.ensureSemicolon = function () {
+  if (!this.isLast(";")) this.semicolon();
+};
+
+Buffer.prototype.rightBrace = function () {
+  this.newline(true);
+  this.push("}");
+};
+
+Buffer.prototype.keyword = function (name) {
+  this.push(name);
+  this.space();
+};
+
+Buffer.prototype.space = function () {
+  if (this.format.compact) return;
+  if (this.buf && !this.isLast(" ") && !this.isLast("\n")) {
+    this.push(" ");
+  }
+};
+
+Buffer.prototype.removeLast = function (cha) {
+  if (this.format.compact) return;
+  if (!this.isLast(cha)) return;
+
+  this.buf = this.buf.substr(0, this.buf.length - 1);
+  this.position.unshift(cha);
+};
+
+Buffer.prototype.newline = function (i, removeLast) {
+  if (this.format.compact) return;
+
+  if (this.format.concise) {
+    this.space();
+    return;
+  }
+
+  removeLast = removeLast || false;
+
+  if (isNumber(i)) {
+    i = Math.min(2, i);
+
+    if (this.endsWith("{\n") || this.endsWith(":\n")) i--;
+    if (i <= 0) return;
+
+    while (i > 0) {
+      this._newline(removeLast);
+      i--;
+    }
+    return;
+  }
+
+  if (isBoolean(i)) {
+    removeLast = i;
+  }
+
+  this._newline(removeLast);
+};
+
+Buffer.prototype._newline = function (removeLast) {
+  // never allow more than two lines
+  if (this.endsWith("\n\n")) return;
+
+  // remove the last newline
+  if (removeLast && this.isLast("\n")) this.removeLast("\n");
+
+  this.removeLast(" ");
+  this._removeSpacesAfterLastNewline();
+  this._push("\n");
+};
+
+/**
+ * If buffer ends with a newline and some spaces after it, trim those spaces.
+ */
+
+Buffer.prototype._removeSpacesAfterLastNewline = function () {
+  var lastNewlineIndex = this.buf.lastIndexOf("\n");
+  if (lastNewlineIndex === -1)
+    return;
+
+  var index = this.buf.length - 1;
+  while (index > lastNewlineIndex) {
+    if (this.buf[index] !== " ") {
+      break;
+    }
+
+    index--;
+  }
+
+  if (index === lastNewlineIndex) {
+    this.buf = this.buf.substring(0, index + 1);
+  }
+};
+
+Buffer.prototype.push = function (str, noIndent) {
+  if (!this.format.compact && this._indent && !noIndent && str !== "\n") {
+    // we have an indent level and we aren't pushing a newline
+    var indent = this.getIndent();
+
+    // replace all newlines with newlines with the indentation
+    str = str.replace(/\n/g, "\n" + indent);
+
+    // we've got a newline before us so prepend on the indentation
+    if (this.isLast("\n")) this._push(indent);
+  }
+
+  this._push(str);
+};
+
+Buffer.prototype._push = function (str) {
+  this.position.push(str);
+  this.buf += str;
+};
+
+Buffer.prototype.endsWith = function (str) {
+  return this.buf.slice(-str.length) === str;
+};
+
+Buffer.prototype.isLast = function (cha) {
+  if (this.format.compact) return false;
+
+  var buf = this.buf;
+  var last = buf[buf.length - 1];
+
+  if (Array.isArray(cha)) {
+    return includes(cha, last);
+  } else {
+    return cha === last;
+  }
+};
+
+},{"lodash/collection/includes":200,"lodash/lang/isBoolean":284,"lodash/lang/isNumber":288,"repeating":321,"trim-right":337}],3:[function(require,module,exports){
+"use strict";
+
+exports.File = function (node, print) {
+  print(node.program);
+};
+
+exports.Program = function (node, print) {
+  print.sequence(node.body);
+};
+
+exports.BlockStatement = function (node, print) {
+  if (node.body.length === 0) {
+    this.push("{}");
+  } else {
+    this.push("{");
+    this.newline();
+    print.sequence(node.body, { indent: true });
+    this.removeLast("\n");
+    this.rightBrace();
+  }
+};
+
+},{}],4:[function(require,module,exports){
+"use strict";
+
+exports.ClassExpression =
+exports.ClassDeclaration = function (node, print) {
+  this.push("class");
+
+  if (node.id) {
+    this.space();
+    print(node.id);
+  }
+
+  if (node.superClass) {
+    this.push(" extends ");
+    print(node.superClass);
+  }
+
+  this.space();
+  print(node.body);
+};
+
+exports.ClassBody = function (node, print) {
+  if (node.body.length === 0) {
+    this.push("{}");
+  } else {
+    this.push("{");
+    this.newline();
+
+    this.indent();
+    print.sequence(node.body);
+    this.dedent();
+
+    this.rightBrace();
+  }
+};
+
+exports.MethodDefinition = function (node, print) {
+  if (node.static) {
+    this.push("static ");
+  }
+
+  this._method(node, print);
+};
+
+},{}],5:[function(require,module,exports){
+"use strict";
+
+exports.ComprehensionBlock = function (node, print) {
+  this.keyword("for");
+  this.push("(");
+  print(node.left);
+  this.push(" of ");
+  print(node.right);
+  this.push(")");
+};
+
+exports.ComprehensionExpression = function (node, print) {
+  this.push(node.generator ? "(" : "[");
+
+  print.join(node.blocks, { separator: " " });
+  this.space();
+
+  if (node.filter) {
+    this.keyword("if");
+    this.push("(");
+    print(node.filter);
+    this.push(")");
+    this.space();
+  }
+
+  print(node.body);
+
+  this.push(node.generator ? ")" : "]");
+};
+
+},{}],6:[function(require,module,exports){
+"use strict";
+
+var isInteger = require("is-integer");
+var isNumber  = require("lodash/lang/isNumber");
+var t         = require("../../types");
+
+exports.UnaryExpression = function (node, print) {
+  var hasSpace = /[a-z]$/.test(node.operator);
+  var arg = node.argument;
+
+  if (t.isUpdateExpression(arg) || t.isUnaryExpression(arg)) {
+    hasSpace = true;
+  }
+
+  if (t.isUnaryExpression(arg) && arg.operator === "!") {
+    hasSpace = false;
+  }
+
+  this.push(node.operator);
+  if (hasSpace) this.push(" ");
+  print(node.argument);
+};
+
+exports.UpdateExpression = function (node, print) {
+  if (node.prefix) {
+    this.push(node.operator);
+    print(node.argument);
+  } else {
+    print(node.argument);
+    this.push(node.operator);
+  }
+};
+
+exports.ConditionalExpression = function (node, print) {
+  print(node.test);
+  this.space();
+  this.push("?");
+  this.space();
+  print(node.consequent);
+  this.space();
+  this.push(":");
+  this.space();
+  print(node.alternate);
+};
+
+exports.NewExpression = function (node, print) {
+  this.push("new ");
+  print(node.callee);
+  this.push("(");
+  print.list(node.arguments);
+  this.push(")");
+};
+
+exports.SequenceExpression = function (node, print) {
+  print.list(node.expressions);
+};
+
+exports.ThisExpression = function () {
+  this.push("this");
+};
+
+exports.CallExpression = function (node, print) {
+  print(node.callee);
+
+  this.push("(");
+
+  var separator = ",";
+
+  if (node._prettyCall) {
+    separator += "\n";
+    this.newline();
+    this.indent();
+  } else {
+    separator += " ";
+  }
+
+  print.list(node.arguments, { separator: separator });
+
+  if (node._prettyCall) {
+    this.newline();
+    this.dedent();
+  }
+
+  this.push(")");
+};
+
+var buildYieldAwait = function (keyword) {
+  return function (node, print) {
+    this.push(keyword);
+
+    if (node.delegate || node.all) {
+      this.push("*");
+    }
+
+    if (node.argument) {
+      this.space();
+      print(node.argument);
+    }
+  };
+};
+
+exports.YieldExpression = buildYieldAwait("yield");
+exports.AwaitExpression = buildYieldAwait("await");
+
+exports.EmptyStatement = function () {
+  this.semicolon();
+};
+
+exports.ExpressionStatement = function (node, print) {
+  print(node.expression);
+  this.semicolon();
+};
+
+exports.BinaryExpression =
+exports.LogicalExpression =
+exports.AssignmentPattern =
+exports.AssignmentExpression = function (node, print) {
+  // todo: add cases where the spaces can be dropped when in compact mode
+  print(node.left);
+  this.push(" ");
+  this.push(node.operator);
+  this.push(" ");
+  print(node.right);
+};
+
+var SCIENTIFIC_NOTATION = /e/i;
+
+exports.MemberExpression = function (node, print) {
+  var obj = node.object;
+  print(obj);
+
+  if (!node.computed && t.isMemberExpression(node.property)) {
+    throw new TypeError("Got a MemberExpression for MemberExpression property");
+  }
+
+  var computed = node.computed;
+  if (t.isLiteral(node.property) && isNumber(node.property.value)) {
+    computed = true;
+  }
+
+  if (computed) {
+    this.push("[");
+    print(node.property);
+    this.push("]");
+  } else {
+    // 5..toFixed(2);
+    if (t.isLiteral(obj) && isInteger(obj.value) && !SCIENTIFIC_NOTATION.test(obj.value.toString())) {
+      this.push(".");
+    }
+
+    this.push(".");
+    print(node.property);
+  }
+};
+
+},{"../../types":119,"is-integer":184,"lodash/lang/isNumber":288}],7:[function(require,module,exports){
+"use strict";
+
+exports.AnyTypeAnnotation =
+exports.ArrayTypeAnnotation =
+exports.BooleanTypeAnnotation =
+exports.ClassProperty =
+exports.DeclareClass =
+exports.DeclareFunction =
+exports.DeclareModule =
+exports.DeclareVariable =
+exports.FunctionTypeAnnotation =
+exports.FunctionTypeParam =
+exports.GenericTypeAnnotation =
+exports.InterfaceExtends =
+exports.InterfaceDeclaration =
+exports.IntersectionTypeAnnotation =
+exports.NullableTypeAnnotation =
+exports.NumberTypeAnnotation =
+exports.StringLiteralTypeAnnotation =
+exports.StringTypeAnnotation =
+exports.TupleTypeAnnotation =
+exports.TypeofTypeAnnotation =
+exports.TypeAlias =
+exports.TypeAnnotation =
+exports.TypeParameterDeclaration =
+exports.TypeParameterInstantiation =
+exports.ObjectTypeAnnotation =
+exports.ObjectTypeCallProperty =
+exports.ObjectTypeIndexer =
+exports.ObjectTypeProperty =
+exports.QualifiedTypeIdentifier =
+exports.UnionTypeAnnotation =
+exports.TypeCastExpression =
+exports.VoidTypeAnnotation = function () {
+  // todo: implement these once we have a `--keep-types` option
+};
+
+},{}],8:[function(require,module,exports){
+"use strict";
+
+var t    = require("../../types");
+var each = require("lodash/collection/each");
+
+exports.JSXAttribute = function (node, print) {
+  print(node.name);
+  if (node.value) {
+    this.push("=");
+    print(node.value);
+  }
+};
+
+exports.JSXIdentifier = function (node) {
+  this.push(node.name);
+};
+
+exports.JSXNamespacedName = function (node, print) {
+  print(node.namespace);
+  this.push(":");
+  print(node.name);
+};
+
+exports.JSXMemberExpression = function (node, print) {
+  print(node.object);
+  this.push(".");
+  print(node.property);
+};
+
+exports.JSXSpreadAttribute = function (node, print) {
+  this.push("{...");
+  print(node.argument);
+  this.push("}");
+};
+
+exports.JSXExpressionContainer = function (node, print) {
+  this.push("{");
+  print(node.expression);
+  this.push("}");
+};
+
+exports.JSXElement = function (node, print) {
+  var self = this;
+
+  var open = node.openingElement;
+  print(open);
+  if (open.selfClosing) return;
+
+  this.indent();
+  each(node.children, function (child) {
+    if (t.isLiteral(child)) {
+      self.push(child.value);
+    } else {
+      print(child);
+    }
+  });
+  this.dedent();
+
+  print(node.closingElement);
+};
+
+exports.JSXOpeningElement = function (node, print) {
+  this.push("<");
+  print(node.name);
+  if (node.attributes.length > 0) {
+    this.push(" ");
+    print.join(node.attributes, { separator: " " });
+  }
+  this.push(node.selfClosing ? " />" : ">");
+};
+
+exports.JSXClosingElement = function (node, print) {
+  this.push("</");
+  print(node.name);
+  this.push(">");
+};
+
+exports.JSXEmptyExpression = function () {};
+
+},{"../../types":119,"lodash/collection/each":197}],9:[function(require,module,exports){
+"use strict";
+
+var t = require("../../types");
+
+exports._params = function (node, print) {
+  this.push("(");
+  print.list(node.params);
+  this.push(")");
+};
+
+exports._method = function (node, print) {
+  var value = node.value;
+  var kind  = node.kind;
+  var key   = node.key;
+
+  if (!kind || kind === "init") {
+    if (value.generator) {
+      this.push("*");
+    }
+  } else {
+    this.push(kind + " ");
+  }
+
+  if (value.async) this.push("async ");
+
+  if (node.computed) {
+    this.push("[");
+    print(key);
+    this.push("]");
+  } else {
+    print(key);
+  }
+
+  this._params(value, print);
+  this.push(" ");
+  print(value.body);
+};
+
+exports.FunctionDeclaration =
+exports.FunctionExpression = function (node, print) {
+  if (node.async) this.push("async ");
+  this.push("function");
+  if (node.generator) this.push("*");
+
+  if (node.id) {
+    this.push(" ");
+    print(node.id);
+  } else {
+    this.space();
+  }
+
+  this._params(node, print);
+  this.space();
+  print(node.body);
+};
+
+exports.ArrowFunctionExpression = function (node, print) {
+  if (node.async) this.push("async ");
+
+  if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
+    print(node.params[0]);
+  } else {
+    this._params(node, print);
+  }
+
+  this.push(" => ");
+  print(node.body);
+};
+
+},{"../../types":119}],10:[function(require,module,exports){
+"use strict";
+
+var t    = require("../../types");
+var each = require("lodash/collection/each");
+
+exports.ImportSpecifier = function (node, print) {
+  if (t.isSpecifierDefault(node)) {
+    print(t.getSpecifierName(node));
+  } else {
+    return exports.ExportSpecifier.apply(this, arguments);
+  }
+};
+
+exports.ExportSpecifier = function (node, print) {
+  print(node.id);
+  if (node.name) {
+    this.push(" as ");
+    print(node.name);
+  }
+};
+
+exports.ExportBatchSpecifier = function () {
+  this.push("*");
+};
+
+exports.ExportDeclaration = function (node, print) {
+  this.push("export ");
+
+  var specifiers = node.specifiers;
+
+  if (node.default) {
+    this.push("default ");
+  }
+
+  if (node.declaration) {
+    print(node.declaration);
+    if (t.isStatement(node.declaration)) return;
+  } else {
+    if (specifiers.length === 1 && t.isExportBatchSpecifier(specifiers[0])) {
+      print(specifiers[0]);
+    } else {
+      this.push("{");
+      if (specifiers.length) {
+        this.space();
+        print.join(specifiers, { separator: ", " });
+        this.space();
+      }
+      this.push("}");
+    }
+
+    if (node.source) {
+      this.push(" from ");
+      print(node.source);
+    }
+  }
+
+  this.ensureSemicolon();
+};
+
+exports.ImportDeclaration = function (node, print) {
+  var self = this;
+
+  this.push("import ");
+
+  if (node.isType) {
+    this.push("type ");
+  }
+
+  var specfiers = node.specifiers;
+  if (specfiers && specfiers.length) {
+    var foundImportSpecifier = false;
+
+    each(node.specifiers, function (spec, i) {
+      if (+i > 0) {
+        self.push(", ");
+      }
+
+      var isDefault = t.isSpecifierDefault(spec);
+
+      if (!isDefault && spec.type !== "ImportBatchSpecifier" && !foundImportSpecifier) {
+        foundImportSpecifier = true;
+        self.push("{ ");
+      }
+
+      print(spec);
+    });
+
+    if (foundImportSpecifier) {
+      this.push(" }");
+    }
+
+    this.push(" from ");
+  }
+
+  print(node.source);
+  this.semicolon();
+};
+
+exports.ImportBatchSpecifier = function (node, print) {
+  this.push("* as ");
+  print(node.name);
+};
+
+},{"../../types":119,"lodash/collection/each":197}],11:[function(require,module,exports){
+"use strict";
+
+var each = require("lodash/collection/each");
+
+each(["BindMemberExpression", "BindFunctionExpression"], function (type) {
+  exports[type] = function () {
+    throw new ReferenceError("Trying to render non-standard playground node " + JSON.stringify(type));
+  };
+});
+
+},{"lodash/collection/each":197}],12:[function(require,module,exports){
+"use strict";
+
+var repeating = require("repeating");
+var t         = require("../../types");
+
+exports.WithStatement = function (node, print) {
+  this.keyword("with");
+  this.push("(");
+  print(node.object);
+  this.push(")");
+  print.block(node.body);
+};
+
+exports.IfStatement = function (node, print) {
+  this.keyword("if");
+  this.push("(");
+  print(node.test);
+  this.push(")");
+  this.space();
+
+  print.indentOnComments(node.consequent);
+
+  if (node.alternate) {
+    if (this.isLast("}")) this.space();
+    this.push("else ");
+    print.indentOnComments(node.alternate);
+  }
+};
+
+exports.ForStatement = function (node, print) {
+  this.keyword("for");
+  this.push("(");
+
+  print(node.init);
+  this.push(";");
+
+  if (node.test) {
+    this.push(" ");
+    print(node.test);
+  }
+  this.push(";");
+
+  if (node.update) {
+    this.push(" ");
+    print(node.update);
+  }
+
+  this.push(")");
+  print.block(node.body);
+};
+
+exports.WhileStatement = function (node, print) {
+  this.keyword("while");
+  this.push("(");
+  print(node.test);
+  this.push(")");
+  print.block(node.body);
+};
+
+var buildForXStatement = function (op) {
+  return function (node, print) {
+    this.keyword("for");
+    this.push("(");
+    print(node.left);
+    this.push(" " + op + " ");
+    print(node.right);
+    this.push(")");
+    print.block(node.body);
+  };
+};
+
+exports.ForInStatement = buildForXStatement("in");
+exports.ForOfStatement = buildForXStatement("of");
+
+exports.DoWhileStatement = function (node, print) {
+  this.keyword("do");
+  print(node.body);
+  this.space();
+  this.keyword("while");
+  this.push("(");
+  print(node.test);
+  this.push(");");
+};
+
+var buildLabelStatement = function (prefix, key) {
+  return function (node, print) {
+    this.push(prefix);
+
+    var label = node[key || "label"];
+    if (label) {
+      this.push(" ");
+      print(label);
+    }
+
+    this.semicolon();
+  };
+};
+
+exports.ContinueStatement = buildLabelStatement("continue");
+exports.ReturnStatement   = buildLabelStatement("return", "argument");
+exports.BreakStatement    = buildLabelStatement("break");
+
+exports.LabeledStatement = function (node, print) {
+  print(node.label);
+  this.push(": ");
+  print(node.body);
+};
+
+exports.TryStatement = function (node, print) {
+  this.keyword("try");
+  print(node.block);
+  this.space();
+
+  // Esprima bug puts the catch clause in a `handlers` array.
+  // see https://code.google.com/p/esprima/issues/detail?id=433
+  // We run into this from regenerator generated ast.
+  if (node.handlers) {
+    print(node.handlers[0]);
+  } else {
+    print(node.handler);
+  }
+
+  if (node.finalizer) {
+    this.space();
+    this.push("finally ");
+    print(node.finalizer);
+  }
+};
+
+exports.CatchClause = function (node, print) {
+  this.keyword("catch");
+  this.push("(");
+  print(node.param);
+  this.push(") ");
+  print(node.body);
+};
+
+exports.ThrowStatement = function (node, print) {
+  this.push("throw ");
+  print(node.argument);
+  this.semicolon();
+};
+
+exports.SwitchStatement = function (node, print) {
+  this.keyword("switch");
+  this.push("(");
+  print(node.discriminant);
+  this.push(")");
+  this.space();
+  this.push("{");
+
+  print.sequence(node.cases, {
+    indent: true,
+    addNewlines: function (leading, cas) {
+      if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
+    }
+  });
+
+  this.push("}");
+};
+
+exports.SwitchCase = function (node, print) {
+  if (node.test) {
+    this.push("case ");
+    print(node.test);
+    this.push(":");
+  } else {
+    this.push("default:");
+  }
+
+  if (node.consequent.length) {
+    this.newline();
+    print.sequence(node.consequent, { indent: true });
+  }
+};
+
+exports.DebuggerStatement = function () {
+  this.push("debugger;");
+};
+
+exports.VariableDeclaration = function (node, print, parent) {
+  this.push(node.kind + " ");
+
+  var hasInits = false;
+  // don't add whitespace to loop heads
+  if (!t.isFor(parent)) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      if (node.declarations[i].init) {
+        // has an init so let's split it up over multiple lines
+        hasInits = true;
+      }
+    }
+  }
+
+  var sep = ",";
+  if (!this.format.compact && hasInits) {
+    sep += "\n" + repeating(" ", node.kind.length + 1);
+  } else {
+    sep += " ";
+  }
+
+  print.list(node.declarations, { separator: sep });
+
+  if (!t.isFor(parent)) {
+    this.semicolon();
+  }
+};
+
+exports.PrivateDeclaration = function (node, print) {
+  this.push("private ");
+  print.join(node.declarations, { separator: ", " });
+  this.semicolon();
+};
+
+exports.VariableDeclarator = function (node, print) {
+  if (node.init) {
+    print(node.id);
+    this.space();
+    this.push("=");
+    this.space();
+    print(node.init);
+  } else {
+    print(node.id);
+  }
+};
+
+},{"../../types":119,"repeating":321}],13:[function(require,module,exports){
+"use strict";
+
+var each = require("lodash/collection/each");
+
+exports.TaggedTemplateExpression = function (node, print) {
+  print(node.tag);
+  print(node.quasi);
+};
+
+exports.TemplateElement = function (node) {
+  this._push(node.value.raw);
+};
+
+exports.TemplateLiteral = function (node, print) {
+  this.push("`");
+
+  var quasis = node.quasis;
+  var self   = this;
+  var len    = quasis.length;
+
+  each(quasis, function (quasi, i) {
+    print(quasi);
+
+    if (i + 1 < len) {
+      self.push("${ ");
+      print(node.expressions[i]);
+      self.push(" }");
+    }
+  });
+
+  this._push("`");
+};
+
+},{"lodash/collection/each":197}],14:[function(require,module,exports){
+"use strict";
+
+var each = require("lodash/collection/each");
+
+exports.Identifier = function (node) {
+  this.push(node.name);
+};
+
+exports.RestElement =
+exports.SpreadElement =
+exports.SpreadProperty = function (node, print) {
+  this.push("...");
+  print(node.argument);
+};
+
+exports.VirtualPropertyExpression = function (node, print) {
+  print(node.object);
+  this.push("::");
+  print(node.property);
+};
+
+exports.ObjectExpression =
+exports.ObjectPattern = function (node, print) {
+  var props = node.properties;
+
+  if (props.length) {
+    this.push("{");
+    this.space();
+
+    print.list(props, { indent: true });
+
+    this.space();
+    this.push("}");
+  } else {
+    this.push("{}");
+  }
+};
+
+exports.Property = function (node, print) {
+  if (node.method || node.kind === "get" || node.kind === "set") {
+    this._method(node, print);
+  } else {
+    if (node.computed) {
+      this.push("[");
+      print(node.key);
+      this.push("]");
+    } else {
+      print(node.key);
+      if (node.shorthand) return;
+    }
+
+    this.push(":");
+    this.space();
+    print(node.value);
+  }
+};
+
+exports.ArrayExpression =
+exports.ArrayPattern = function (node, print) {
+  var elems = node.elements;
+  var self  = this;
+  var len   = elems.length;
+
+  this.push("[");
+
+  each(elems, function (elem, i) {
+    if (!elem) {
+      // If the array expression ends with a hole, that hole
+      // will be ignored by the interpreter, but if it ends with
+      // two (or more) holes, we need to write out two (or more)
+      // commas so that the resulting code is interpreted with
+      // both (all) of the holes.
+      self.push(",");
+    } else {
+      if (i > 0) self.push(" ");
+      print(elem);
+      if (i < len - 1) self.push(",");
+    }
+  });
+
+  this.push("]");
+};
+
+exports.Literal = function (node) {
+  var val  = node.value;
+  var type = typeof val;
+
+  if (type === "string") {
+    val = JSON.stringify(val);
+
+    // escape illegal js but valid json unicode characters
+    val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
+      return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
+    });
+
+    this.push(val);
+  } else if (type === "number") {
+    this.push(val + "");
+  } else if (type === "boolean") {
+    this.push(val ? "true" : "false");
+  } else if (node.regex) {
+    this.push("/" + node.regex.pattern + "/" + node.regex.flags);
+  } else if (val === null) {
+    this.push("null");
+  }
+};
+
+},{"lodash/collection/each":197}],15:[function(require,module,exports){
+"use strict";
+
+module.exports = function (ast, opts, code) {
+  var gen = new CodeGenerator(ast, opts, code);
+  return gen.generate();
+};
+
+module.exports.CodeGenerator = CodeGenerator;
+
+var detectIndent = require("detect-indent");
+var Whitespace   = require("./whitespace");
+var repeating    = require("repeating");
+var SourceMap    = require("./source-map");
+var Position     = require("./position");
+var messages     = require("../messages");
+var Buffer       = require("./buffer");
+var extend       = require("lodash/object/extend");
+var each         = require("lodash/collection/each");
+var n            = require("./node");
+var t            = require("../types");
+
+function CodeGenerator(ast, opts, code) {
+  opts = opts || {};
+
+  this.comments = ast.comments || [];
+  this.tokens   = ast.tokens || [];
+  this.format   = CodeGenerator.normalizeOptions(code, opts);
+  this.opts     = opts;
+  this.ast      = ast;
+
+  this.whitespace = new Whitespace(this.tokens, this.comments, this.format);
+  this.position   = new Position;
+  this.map        = new SourceMap(this.position, opts, code);
+  this.buffer     = new Buffer(this.position, this.format);
+}
+
+each(Buffer.prototype, function (fn, key) {
+  CodeGenerator.prototype[key] = function () {
+    return fn.apply(this.buffer, arguments);
+  };
+});
+
+CodeGenerator.normalizeOptions = function (code, opts) {
+  var style = "  ";
+  if (code) {
+    var indent = detectIndent(code).indent;
+    if (indent && indent !== " ") style = indent;
+  }
+
+  var format = {
+    comments: opts.comments == null || opts.comments,
+    compact: opts.compact,
+    indent: {
+      adjustMultilineComment: true,
+      style: style,
+      base: 0
+    }
+  };
+
+  if (format.compact === "auto") {
+    format.compact = code.length > 100000; // 100KB
+
+    if (format.compact) {
+      console.error(messages.get("codeGeneratorDeopt", opts.filename, "100KB"));
+    }
+  }
+
+  return format;
+};
+
+CodeGenerator.generators = {
+  templateLiterals: require("./generators/template-literals"),
+  comprehensions:   require("./generators/comprehensions"),
+  expressions:      require("./generators/expressions"),
+  statements:       require("./generators/statements"),
+  playground:       require("./generators/playground"),
+  classes:          require("./generators/classes"),
+  methods:          require("./generators/methods"),
+  modules:          require("./generators/modules"),
+  types:            require("./generators/types"),
+  flow:             require("./generators/flow"),
+  base:             require("./generators/base"),
+  jsx:              require("./generators/jsx")
+};
+
+each(CodeGenerator.generators, function (generator) {
+  extend(CodeGenerator.prototype, generator);
+});
+
+CodeGenerator.prototype.generate = function () {
+  var ast = this.ast;
+
+  this.print(ast);
+
+  var comments = [];
+  each(ast.comments, function (comment) {
+    if (!comment._displayed) comments.push(comment);
+  });
+  this._printComments(comments);
+
+  return {
+    map:  this.map.get(),
+    code: this.buffer.get()
+  };
+};
+
+CodeGenerator.prototype.buildPrint = function (parent) {
+  var self = this;
+
+  var print = function (node, opts) {
+    return self.print(node, parent, opts);
+  };
+
+  print.sequence = function (nodes, opts) {
+    opts = opts || {};
+    opts.statement = true;
+    return self.printJoin(print, nodes, opts);
+  };
+
+  print.join = function (nodes, opts) {
+    return self.printJoin(print, nodes, opts);
+  };
+
+  print.list = function (items, opts) {
+    opts = opts || {};
+    opts.separator = opts.separator || ", ";
+    print.join(items, opts);
+  };
+
+  print.block = function (node) {
+    return self.printBlock(print, node);
+  };
+
+  print.indentOnComments = function (node) {
+    return self.printAndIndentOnComments(print, node);
+  };
+
+  return print;
+};
+
+CodeGenerator.prototype.print = function (node, parent, opts) {
+  if (!node) return "";
+
+  if (parent && parent._compact) {
+    node._compact = true;
+  }
+
+  var oldConcise = this.format.concise;
+  if (node._compact) {
+    this.format.concise = true;
+  }
+
+  var self = this;
+
+  opts = opts || {};
+
+  var newline = function (leading) {
+    if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
+      return;
+    }
+
+    var lines = 0;
+
+    if (node.start != null && !node._ignoreUserWhitespace) {
+      // user node
+      if (leading) {
+        lines = self.whitespace.getNewlinesBefore(node);
+      } else {
+        lines = self.whitespace.getNewlinesAfter(node);
+      }
+    } else {
+      // generated node
+      if (!leading) lines++; // always include at least a single line after
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
+
+      var needs = n.needsWhitespaceAfter;
+      if (leading) needs = n.needsWhitespaceBefore;
+      if (needs(node, parent)) lines++;
+
+      // generated nodes can't add starting file whitespace
+      if (!self.buffer.buf) lines = 0;
+    }
+
+    self.newline(lines);
+  };
+
+  if (this[node.type]) {
+    var needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
+    var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
+
+    if (needsParens) this.push("(");
+    if (needsNoLineTermParens) this.indent();
+
+    this.printLeadingComments(node, parent);
+
+    newline(true);
+
+    if (opts.before) opts.before();
+    this.map.mark(node, "start");
+
+    this[node.type](node, this.buildPrint(node), parent);
+
+    if (needsNoLineTermParens) {
+      this.newline();
+      this.dedent();
+    }
+    if (needsParens) this.push(")");
+
+    this.map.mark(node, "end");
+    if (opts.after) opts.after();
+
+    newline(false);
+
+    this.printTrailingComments(node, parent);
+  } else {
+    throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
+  }
+
+  this.format.concise = oldConcise;
+};
+
+CodeGenerator.prototype.printJoin = function (print, nodes, opts) {
+  if (!nodes || !nodes.length) return;
+
+  opts = opts || {};
+
+  var self = this;
+  var len  = nodes.length;
+
+  if (opts.indent) self.indent();
+
+  each(nodes, function (node, i) {
+    print(node, {
+      statement: opts.statement,
+      addNewlines: opts.addNewlines,
+      after: function () {
+        if (opts.iterator) {
+          opts.iterator(node, i);
+        }
+
+        if (opts.separator && i < len - 1) {
+          self.push(opts.separator);
+        }
+      }
+    });
+  });
+
+  if (opts.indent) self.dedent();
+};
+
+CodeGenerator.prototype.printAndIndentOnComments = function (print, node) {
+  var indent = !!node.leadingComments;
+  if (indent) this.indent();
+  print(node);
+  if (indent) this.dedent();
+};
+
+CodeGenerator.prototype.printBlock = function (print, node) {
+  if (t.isEmptyStatement(node)) {
+    this.semicolon();
+  } else {
+    this.push(" ");
+    print(node);
+  }
+};
+
+CodeGenerator.prototype.generateComment = function (comment) {
+  var val = comment.value;
+  if (comment.type === "Line") {
+    val = "//" + val;
+  } else {
+    val = "/*" + val + "*/";
+  }
+  return val;
+};
+
+CodeGenerator.prototype.printTrailingComments = function (node, parent) {
+  this._printComments(this.getComments("trailingComments", node, parent));
+};
+
+CodeGenerator.prototype.printLeadingComments = function (node, parent) {
+  this._printComments(this.getComments("leadingComments", node, parent));
+};
+
+CodeGenerator.prototype.getComments = function (key, node, parent) {
+  if (t.isExpressionStatement(parent)) {
+    return [];
+  }
+
+  var comments = [];
+  var nodes    = [node];
+  var self     = this;
+
+  if (t.isExpressionStatement(node)) {
+    nodes.push(node.argument);
+  }
+
+  each(nodes, function (node) {
+    comments = comments.concat(self._getComments(key, node));
+  });
+
+  return comments;
+};
+
+CodeGenerator.prototype._getComments = function (key, node) {
+  return (node && node[key]) || [];
+};
+
+CodeGenerator.prototype._printComments = function (comments) {
+  if (this.format.compact) return;
+
+  if (!this.format.comments) return;
+  if (!comments || !comments.length) return;
+
+  var self = this;
+
+  each(comments, function (comment) {
+    var skip = false;
+
+    // find the original comment in the ast and set it as displayed
+    each(self.ast.comments, function (origComment) {
+      if (origComment.start === comment.start) {
+        // comment has already been output
+        if (origComment._displayed) skip = true;
+
+        origComment._displayed = true;
+        return false;
+      }
+    });
+
+    if (skip) return;
+
+    // whitespace before
+    self.newline(self.whitespace.getNewlinesBefore(comment));
+
+    var column = self.position.column;
+    var val    = self.generateComment(comment);
+
+    if (column && !self.isLast(["\n", " ", "[", "{"])) {
+      self._push(" ");
+      column++;
+    }
+
+    //
+
+    if (comment.type === "Block" && self.format.indent.adjustMultilineComment) {
+      var offset = comment.loc.start.column;
+      if (offset) {
+        var newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+        val = val.replace(newlineRegex, "\n");
+      }
+
+      var indent = Math.max(self.indentSize(), column);
+      val = val.replace(/\n/g, "\n" + repeating(" ", indent));
+    }
+
+    if (column === 0) {
+      val = self.getIndent() + val;
+    }
+
+    //
+
+    self._push(val);
+
+    // whitespace after
+    self.newline(self.whitespace.getNewlinesAfter(comment));
+  });
+};
+
+},{"../messages":27,"../types":119,"./buffer":2,"./generators/base":3,"./generators/classes":4,"./generators/comprehensions":5,"./generators/expressions":6,"./generators/flow":7,"./generators/jsx":8,"./generators/methods":9,"./generators/modules":10,"./generators/playground":11,"./generators/statements":12,"./generators/template-literals":13,"./generators/types":14,"./node":16,"./position":19,"./source-map":20,"./whitespace":21,"detect-indent":176,"lodash/collection/each":197,"lodash/object/extend":295,"repeating":321}],16:[function(require,module,exports){
+"use strict";
+
+module.exports = Node;
+
+var whitespace = require("./whitespace");
+var parens     = require("./parentheses");
+var each       = require("lodash/collection/each");
+var some       = require("lodash/collection/some");
+var t          = require("../../types");
+
+var find = function (obj, node, parent) {
+  if (!obj) return;
+  var result;
+
+  var types = Object.keys(obj);
+  for (var i = 0; i < types.length; i++) {
+    var type = types[i];
+
+    if (t.is(type, node)) {
+      var fn = obj[type];
+      result = fn(node, parent);
+      if (result != null) break;
+    }
+  }
+
+  return result;
+};
+
+function Node(node, parent) {
+  this.parent = parent;
+  this.node   = node;
+}
+
+Node.isUserWhitespacable = function (node) {
+  return t.isUserWhitespacable(node);
+};
+
+Node.needsWhitespace = function (node, parent, type) {
+  if (!node) return 0;
+
+  if (t.isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  var linesInfo = find(whitespace.nodes, node, parent);
+
+  if (!linesInfo) {
+    var items = find(whitespace.list, node, parent);
+    if (items) {
+      for (var i = 0; i < items.length; i++) {
+        linesInfo = Node.needsWhitespace(items[i], node, type);
+        if (linesInfo) break;
+      }
+    }
+  }
+
+  return (linesInfo && linesInfo[type]) || 0;
+};
+
+Node.needsWhitespaceBefore = function (node, parent) {
+  return Node.needsWhitespace(node, parent, "before");
+};
+
+Node.needsWhitespaceAfter = function (node, parent) {
+  return Node.needsWhitespace(node, parent, "after");
+};
+
+Node.needsParens = function (node, parent) {
+  if (!parent) return false;
+
+  if (t.isNewExpression(parent) && parent.callee === node) {
+    if (t.isCallExpression(node)) return true;
+
+    var hasCall = some(node, function (val) {
+      return t.isCallExpression(val);
+    });
+    if (hasCall) return true;
+  }
+
+  return find(parens, node, parent);
+};
+
+Node.needsParensNoLineTerminator = function (node, parent) {
+  if (!parent) return false;
+
+  // no comments
+  if (!node.leadingComments || !node.leadingComments.length) {
+    return false;
+  }
+
+  if (t.isYieldExpression(parent) || t.isAwaitExpression(parent)) {
+    return true;
+  }
+
+  if (t.isContinueStatement(parent) || t.isBreakStatement(parent) ||
+      t.isReturnStatement(parent) || t.isThrowStatement(parent)) {
+    return true;
+  }
+
+  return false;
+};
+
+each(Node, function (fn, key) {
+  Node.prototype[key] = function () {
+    // Avoid leaking arguments to prevent deoptimization
+    var args = new Array(arguments.length + 2);
+
+    args[0] = this.node;
+    args[1] = this.parent;
+
+    for (var i = 0; i < args.length; i++) {
+      args[i + 2] = arguments[i];
+    }
+
+    return Node[key].apply(null, args);
+  };
+});
+
+},{"../../types":119,"./parentheses":17,"./whitespace":18,"lodash/collection/each":197,"lodash/collection/some":203}],17:[function(require,module,exports){
+"use strict";
+
+var t    = require("../../types");
+var each = require("lodash/collection/each");
+
+var PRECEDENCE = {};
+
+each([
+  ["||"],
+  ["&&"],
+  ["|"],
+  ["^"],
+  ["&"],
+  ["==", "===", "!=", "!=="],
+  ["<", ">", "<=", ">=", "in", "instanceof"],
+  [">>", "<<", ">>>"],
+  ["+", "-"],
+  ["*", "/", "%"],
+  ["**"]
+], function (tier, i) {
+  each(tier, function (op) {
+    PRECEDENCE[op] = i;
+  });
+});
+
+exports.UpdateExpression = function (node, parent) {
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    // (foo++).test()
+    return true;
+  }
+};
+
+exports.ObjectExpression = function (node, parent) {
+  if (t.isExpressionStatement(parent)) {
+    // ({ foo: "bar" });
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    // ({ foo: "bar" }).foo
+    return true;
+  }
+
+  return false;
+};
+
+exports.Binary = function (node, parent) {
+  if ((t.isCallExpression(parent) || t.isNewExpression(parent)) && parent.callee === node) {
+    return true;
+  }
+
+  if (t.isUnaryLike(parent)) {
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  if (t.isBinary(parent)) {
+    var parentOp  = parent.operator;
+    var parentPos = PRECEDENCE[parentOp];
+
+    var nodeOp = node.operator;
+    var nodePos = PRECEDENCE[nodeOp];
+
+    if (parentPos > nodePos) {
+      return true;
+    }
+
+    if (parentPos === nodePos && parent.right === node) {
+      return true;
+    }
+  }
+};
+
+exports.BinaryExpression = function (node, parent) {
+  if (node.operator === "in") {
+    // var i = (1 in []);
+    if (t.isVariableDeclarator(parent)) {
+      return true;
+    }
+
+    // for ((1 in []);;);
+    if (t.isFor(parent)) {
+      return true;
+    }
+  }
+};
+
+exports.SequenceExpression = function (node, parent) {
+  if (t.isForStatement(parent)) {
+    // Although parentheses wouldn't hurt around sequence
+    // expressions in the head of for loops, traditional style
+    // dictates that e.g. i++, j++ should not be wrapped with
+    // parentheses.
+    return false;
+  }
+
+  if (t.isExpressionStatement(parent) && parent.expression === node) {
+    return false;
+  }
+
+  // Otherwise err on the side of overparenthesization, adding
+  // explicit exceptions above if this proves overzealous.
+  return true;
+};
+
+exports.YieldExpression = function (node, parent) {
+  return t.isBinary(parent) ||
+         t.isUnaryLike(parent) ||
+         t.isCallExpression(parent) ||
+         t.isMemberExpression(parent) ||
+         t.isNewExpression(parent) ||
+         t.isConditionalExpression(parent) ||
+         t.isYieldExpression(parent);
+};
+
+exports.ClassExpression = function (node, parent) {
+  return t.isExpressionStatement(parent);
+};
+
+exports.UnaryLike = function (node, parent) {
+  return t.isMemberExpression(parent) && parent.object === node;
+};
+
+exports.FunctionExpression = function (node, parent) {
+  // function () {};
+  if (t.isExpressionStatement(parent)) {
+    return true;
+  }
+
+  // (function test() {}).name;
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  // (function () {})();
+  if (t.isCallExpression(parent) && parent.callee === node) {
+    return true;
+  }
+};
+
+exports.AssignmentExpression =
+exports.ConditionalExpression = function (node, parent) {
+  if (t.isUnaryLike(parent)) {
+    return true;
+  }
+
+  if (t.isBinary(parent)) {
+    return true;
+  }
+
+  if (t.isCallExpression(parent) || t.isNewExpression(parent)) {
+    if (parent.callee === node) {
+      return true;
+    }
+  }
+
+  if (t.isConditionalExpression(parent) && parent.test === node) {
+    return true;
+  }
+
+  if (t.isMemberExpression(parent) && parent.object === node) {
+    return true;
+  }
+
+  return false;
+};
+
+},{"../../types":119,"lodash/collection/each":197}],18:[function(require,module,exports){
+"use strict";
+
+var isBoolean = require("lodash/lang/isBoolean");
+var each      = require("lodash/collection/each");
+var map       = require("lodash/collection/map");
+var t         = require("../../types");
+
+var crawl = function (node, state) {
+  state = state || {};
+
+  if (t.isMemberExpression(node)) {
+    crawl(node.object, state);
+    if (node.computed) crawl(node.property, state);
+  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
+    crawl(node.left, state);
+    crawl(node.right, state);
+  } else if (t.isCallExpression(node)) {
+    state.hasCall = true;
+    crawl(node.callee, state);
+  } else if (t.isFunction(node)) {
+    state.hasFunction = true;
+  } else if (t.isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
+  }
+
+  return state;
+};
+
+var isHelper = function (node) {
+  if (t.isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (t.isIdentifier(node)) {
+    return node.name === "require" || node.name[0] === "_";
+  } else if (t.isCallExpression(node)) {
+    return isHelper(node.callee);
+  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
+    return (t.isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right);
+  } else {
+    return false;
+  }
+};
+
+var isType = function (node) {
+  return t.isLiteral(node) || t.isObjectExpression(node) || t.isArrayExpression(node) ||
+         t.isIdentifier(node) || t.isMemberExpression(node);
+};
+
+exports.nodes = {
+  AssignmentExpression: function (node) {
+    var state = crawl(node.right);
+    if ((state.hasCall && state.hasHelper) || state.hasFunction) {
+      return {
+        before: state.hasFunction,
+        after: true
+      };
+    }
+  },
+
+  SwitchCase: function (node, parent) {
+    return {
+      before: node.consequent.length || parent.cases[0] === node
+    };
+  },
+
+  LogicalExpression: function (node) {
+    if (t.isFunction(node.left) || t.isFunction(node.right)) {
+      return {
+        after: true
+      };
+    }
+  },
+
+  Literal: function (node) {
+    if (node.value === "use strict") {
+      return {
+        after: true
+      };
+    }
+  },
+
+  CallExpression: function (node) {
+    if (t.isFunction(node.callee) || isHelper(node)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  },
+
+  VariableDeclaration: function (node) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
+
+      var enabled = isHelper(declar.id) && !isType(declar.init);
+      if (!enabled) {
+        var state = crawl(declar.init);
+        enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
+      }
+
+      if (enabled) {
+        return {
+          before: true,
+          after: true
+        };
+      }
+    }
+  },
+
+  IfStatement: function (node) {
+    if (t.isBlockStatement(node.consequent)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
+  }
+};
+
+exports.nodes.Property =
+exports.nodes.SpreadProperty = function (node, parent) {
+  if (parent.properties[0] === node) {
+    return {
+      before: true
+    };
+  }
+};
+
+exports.list = {
+  VariableDeclaration: function (node) {
+    return map(node.declarations, "init");
+  },
+
+  ArrayExpression: function (node) {
+    return node.elements;
+  },
+
+  ObjectExpression: function (node) {
+    return node.properties;
+  }
+};
+
+each({
+  Function: true,
+  Class: true,
+  Loop: true,
+  LabeledStatement: true,
+  SwitchStatement: true,
+  TryStatement: true
+}, function (amounts, type) {
+  if (isBoolean(amounts)) {
+    amounts = { after: amounts, before: amounts };
+  }
+
+  each([type].concat(t.FLIPPED_ALIAS_KEYS[type] || []), function (type) {
+    exports.nodes[type] = function () {
+      return amounts;
+    };
+  });
+});
+
+},{"../../types":119,"lodash/collection/each":197,"lodash/collection/map":201,"lodash/lang/isBoolean":284}],19:[function(require,module,exports){
+"use strict";
+
+module.exports = Position;
+
+function Position() {
+  this.line = 1;
+  this.column = 0;
+}
+
+Position.prototype.push = function (str) {
+  for (var i = 0; i < str.length; i++) {
+    if (str[i] === "\n") {
+      this.line++;
+      this.column = 0;
+    } else {
+      this.column++;
+    }
+  }
+};
+
+Position.prototype.unshift = function (str) {
+  for (var i = 0; i < str.length; i++) {
+    if (str[i] === "\n") {
+      this.line--;
+    } else {
+      this.column--;
+    }
+  }
+};
+
+},{}],20:[function(require,module,exports){
+"use strict";
+
+module.exports = SourceMap;
+
+var sourceMap = require("source-map");
+var t         = require("../types");
+
+function SourceMap(position, opts, code) {
+  this.position = position;
+  this.opts     = opts;
+
+  if (opts.sourceMap) {
+    this.map = new sourceMap.SourceMapGenerator({
+      file: opts.sourceMapName,
+      sourceRoot: opts.sourceRoot
+    });
+
+    this.map.setSourceContent(opts.sourceFileName, code);
+  } else {
+    this.map = null;
+  }
+}
+
+SourceMap.prototype.get = function () {
+  var map = this.map;
+  if (map) {
+    return map.toJSON();
+  } else {
+    return map;
+  }
+};
+
+SourceMap.prototype.mark = function (node, type) {
+  var loc = node.loc;
+  if (!loc) return; // no location info
+
+  var map = this.map;
+  if (!map) return; // no source map
+
+  if (t.isProgram(node) || t.isFile(node)) return; // illegal mapping nodes
+
+  var position = this.position;
+
+  var generated = {
+    line: position.line,
+    column: position.column
+  };
+
+  var original = loc[type];
+
+  map.addMapping({
+    source: this.opts.sourceFileName,
+    generated: generated,
+    original: original
+  });
+};
+
+},{"../types":119,"source-map":326}],21:[function(require,module,exports){
+"use strict";
+
+module.exports = Whitespace;
+
+var sortBy = require("lodash/collection/sortBy");
+
+/**
+ * Returns `i`th number from `base`, continuing from 0 when `max` is reached.
+ * Useful for shifting `for` loop by a fixed number but going over all items.
+ *
+ * @param {Number} i Current index in the loop
+ * @param {Number} base Start index for which to return 0
+ * @param {Number} max Array length
+ * @returns {Number} shiftedIndex
+ */
+
+function getLookupIndex(i, base, max) {
+  i += base;
+
+  if (i >= max) {
+    i -= max;
+  }
+
+  return i;
+}
+
+function Whitespace(tokens, comments) {
+  this.tokens = sortBy(tokens.concat(comments), "start");
+  this.used   = {};
+
+  // Profiling this code shows that while generator passes over it, indexes
+  // returned by `getNewlinesBefore` and `getNewlinesAfter` are always increasing.
+
+  // We use this implementation detail for an optimization: instead of always
+  // starting to look from `this.tokens[0]`, we will start `for` loops from the
+  // previous successful match. We will enumerate all tokens—but the common
+  // case will be much faster.
+
+  this._lastFoundIndex = 0;
+}
+
+Whitespace.prototype.getNewlinesBefore = function (node) {
+  var startToken;
+  var endToken;
+  var tokens = this.tokens;
+  var token;
+
+  for (var j = 0; j < tokens.length; j++) {
+    // optimize for forward traversal by shifting for loop index
+    var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
+    token = tokens[i];
+
+    // this is the token this node starts with
+    if (node.start === token.start) {
+      startToken = tokens[i - 1];
+      endToken = token;
+
+      this._lastFoundIndex = i;
+      break;
+    }
+  }
+
+  return this.getNewlinesBetween(startToken, endToken);
+};
+
+Whitespace.prototype.getNewlinesAfter = function (node) {
+  var startToken;
+  var endToken;
+  var tokens = this.tokens;
+  var token;
+
+  for (var j = 0; j < tokens.length; j++) {
+    // optimize for forward traversal by shifting for loop index
+    var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
+    token = tokens[i];
+
+    // this is the token this node ends with
+    if (node.end === token.end) {
+      startToken = token;
+      endToken = tokens[i + 1];
+
+      this._lastFoundIndex = i;
+      break;
+    }
+  }
+
+  if (endToken && endToken.type.type === "eof") {
+    return 1;
+  } else {
+    var lines = this.getNewlinesBetween(startToken, endToken);
+    if (node.type === "Line" && !lines) {
+      // line comment
+      return 1;
+    } else {
+      return lines;
+    }
+  }
+};
+
+Whitespace.prototype.getNewlinesBetween = function (startToken, endToken) {
+  if (!endToken || !endToken.loc) return 0;
+
+  var start = startToken ? startToken.loc.end.line : 1;
+  var end   = endToken.loc.start.line;
+  var lines = 0;
+
+  for (var line = start; line < end; line++) {
+    if (typeof this.used[line] === "undefined") {
+      this.used[line] = true;
+      lines++;
+    }
+  }
+
+  return lines;
+};
+
+},{"lodash/collection/sortBy":204}],22:[function(require,module,exports){
+var lineNumbers = require("line-numbers");
+var repeating   = require("repeating");
+var jsTokens    = require("js-tokens");
+var esutils     = require("esutils");
+var chalk       = require("chalk");
+var ary         = require("lodash/function/ary");
+
+var defs = {
+  string:      chalk.red,
+  punctuation: chalk.white.bold,
+  operator:    chalk.white.bold,
+  curly:       chalk.green,
+  parens:      chalk.blue.bold,
+  square:      chalk.yellow,
+  name:        chalk.white,
+  keyword:     chalk.cyan,
+  number:      chalk.magenta,
+  regex:       chalk.magenta,
+  comment:     chalk.grey,
+  invalid:     chalk.inverse
+};
+
+var newline = /\r\n|[\n\r\u2028\u2029]/;
+
+var highlight = function (text) {
+  var tokenType = function (match) {
+    var token = jsTokens.matchToToken(match);
+    if (token.type === "name" && esutils.keyword.isKeywordES6(token.value)) {
+      return "keyword";
+    }
+
+    if (token.type === "punctuation") {
+      switch (token.value) {
+        case "{":
+        case "}":
+          return "curly";
+        case "(":
+        case ")":
+          return "parens";
+        case "[":
+        case "]":
+          return "square";
+      }
+    }
+
+    return token.type;
+  };
+
+  return text.replace(jsTokens, function (match) {
+    var type = tokenType(arguments);
+    if (type in defs) {
+      var colorize = ary(defs[type], 1);
+      return match.split(newline).map(colorize).join("\n");
+    }
+    return match;
+  });
+};
+
+module.exports = function (lines, lineNumber, colNumber) {
+  colNumber = Math.max(colNumber, 0);
+
+  if (chalk.supportsColor) {
+    lines = highlight(lines);
+  }
+
+  lines = lines.split(newline);
+
+  var start = Math.max(lineNumber - 3, 0);
+  var end   = Math.min(lines.length, lineNumber + 3);
+
+  if (!lineNumber && !colNumber) {
+    start = 0;
+    end = lines.length;
+  }
+
+  return "\n" + lineNumbers(lines.slice(start, end), {
+    start: start + 1,
+    before: "  ",
+    after: " | ",
+    transform: function (params) {
+      if (params.number !== lineNumber) {
+        return;
+      }
+      if (colNumber) {
+        params.line += "\n" + params.before + repeating(" ", params.width) +
+                       params.after + repeating(" ", colNumber - 1) + "^";
+      }
+      params.before = params.before.replace(/^./, ">");
+    }
+  }).join("\n");
+};
+
+},{"chalk":164,"esutils":181,"js-tokens":187,"line-numbers":189,"lodash/function/ary":206,"repeating":321}],23:[function(require,module,exports){
+var t = require("../types");
+
+module.exports = function (ast, comments, tokens) {
+  if (ast && ast.type === "Program") {
+    return t.file(ast, comments || [], tokens || []);
+  } else {
+    throw new Error("Not a valid ast?");
+  }
+};
+
+},{"../types":119}],24:[function(require,module,exports){
+"use strict";
+
+module.exports = function () {
+  return Object.create(null);
+};
+
+},{}],25:[function(require,module,exports){
+var normalizeAst = require("./normalize-ast");
+var estraverse   = require("estraverse");
+var codeFrame    = require("./code-frame");
+var acorn        = require("acorn-babel");
+
+module.exports = function (opts, code, callback) {
+  try {
+    var comments = [];
+    var tokens   = [];
+
+    var ast = acorn.parse(code, {
+      allowImportExportEverywhere: opts.allowImportExportEverywhere,
+      allowReturnOutsideFunction:  !opts._anal,
+      ecmaVersion:                 opts.experimental ? 7 : 6,
+      playground:                  opts.playground,
+      strictMode:                  opts.strictMode,
+      onComment:                   comments,
+      locations:                   true,
+      onToken:                     tokens,
+      ranges:                      true
+    });
+
+    estraverse.attachComments(ast, comments, tokens);
+
+    ast = normalizeAst(ast, comments, tokens);
+
+    if (callback) {
+      return callback(ast);
+    } else {
+      return ast;
+    }
+  } catch (err) {
+    if (!err._babel) {
+      err._babel = true;
+      var message = opts.filename + ": " + err.message;
+
+      var loc = err.loc;
+      if (loc) {
+        var frame = codeFrame(code, loc.line, loc.column + 1);
+        message += frame;
+      }
+
+      if (err.stack) err.stack = err.stack.replace(err.message, message);
+      err.message = message;
+    }
+
+    throw err;
+  }
+};
+
+},{"./code-frame":22,"./normalize-ast":23,"acorn-babel":122,"estraverse":177}],26:[function(require,module,exports){
+"use strict";
+
+/**
+ * A trick from Bluebird to force V8 to use fast properties for an object.
+ * Read more: http://stackoverflow.com/questions/24987896/
+ *
+ * Use %HasFastProperties(obj) and --allow-natives-syntax to check whether
+ * a particular object already has fast properties.
+ */
+
+module.exports = function toFastProperties(obj) {
+  /*jshint -W027*/
+  function f() {}
+  f.prototype = obj;
+  return f;
+  eval(obj);
+};
+
+},{}],27:[function(require,module,exports){
+var util = require("util");
+
+exports.messages = {
+  tailCallReassignmentDeopt: "Function reference has been reassigned so it's probably be dereferenced so we can't optimise this with confidence",
+  JSXNamespacedTags: "Namespace tags are not supported. ReactJSX is not XML.",
+  classesIllegalBareSuper: "Illegal use of bare super",
+  classesIllegalSuperCall: "Direct super call is illegal in non-constructor, use super.$1() instead",
+  classesIllegalConstructorKind: "Illegal kind for constructor method",
+  scopeDuplicateDeclaration: "Duplicate declaration $1",
+  undeclaredVariable: "Reference to undeclared variable $1",
+  undeclaredVariableSuggestion: "Reference to undeclared variable $1 - did you mean $2?",
+  settersInvalidParamLength: "Setters must have exactly one parameter",
+  noAssignmentsInForHead: "No assignments allowed in for-in/of head",
+  expectedMemberExpressionOrIdentifier: "Expected type MemeberExpression or Identifier",
+  invalidParentForThisNode: "We don't know how to handle this node within the current parent - please open an issue",
+  readOnly: "$1 is read-only",
+  modulesIllegalExportName: "Illegal export $1",
+  unknownForHead: "Unknown node type $1 in ForStatement",
+  didYouMean: "Did you mean $1?",
+  evalInStrictMode: "eval is not allowed in strict mode",
+  codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2."
+};
+
+exports.get = function (key) {
+  var msg = exports.messages[key];
+  if (!msg) throw new ReferenceError("Unknown message `" + key + "`");
+
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) {
+    args.push(arguments[i]);
+  }
+  args = exports.parseArgs(args);
+
+  return msg.replace(/\$(\d+)/g, function (str, i) {
+    return args[--i];
+  });
+};
+
+exports.parseArgs = function (args) {
+  return args.map(function (val) {
+    if (val != null && val.inspect) {
+      return val.inspect();
+    } else {
+      try {
+        return JSON.stringify(val) || val + "";
+      } catch (e) {
+        return util.inspect(val);
+      }
+    }
+  });
+};
+
+},{"util":163}],28:[function(require,module,exports){
+"use strict";
+
+var extend = require("lodash/object/extend");
+var t      = require("./types");
+
+// estraverse
+
+var estraverse = require("estraverse");
+extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
+
+// regenerator-babel/ast-types
+
+var types = require("ast-types");
+var def   = types.Type.def;
+var or    = types.Type.or;
+
+def("File")
+  .bases("Node")
+  .build("program")
+  .field("program", def("Program"));
+
+def("AssignmentPattern")
+  .bases("Pattern")
+  .build("left", "right")
+  .field("left", def("Pattern"))
+  .field("right", def("Expression"));
+
+// Acorn - Same as ImportNamespaceSpecifier but `id` is `name`
+def("ImportBatchSpecifier")
+  .bases("Specifier")
+  .build("name")
+  .field("name", def("Identifier"));
+
+def("RestElement")
+  .bases("Pattern")
+  .build("argument")
+  .field("argument", def("expression"));
+
+// Abstract references
+def("VirtualPropertyExpression")
+  .bases("Expression")
+  .build("object", "property")
+  .field("object", def("Expression"))
+  .field("property", or(def("Identifier"), def("Expression")));
+
+def("PrivateDeclaration")
+  .bases("Declaration")
+  .build("declarations")
+  .field("declarations", [def("Identifier")]);
+
+// Playground
+def("BindMemberExpression")
+  .bases("Expression")
+  .build("object", "property", "arguments")
+  .field("object", def("Expression"))
+  .field("property", or(def("Identifier"), def("Expression")))
+  .field("arguments", [def("Expression")]);
+
+def("BindFunctionExpression")
+  .bases("Expression")
+  .build("callee", "arguments")
+  .field("callee", def("Expression"))
+  .field("arguments", [def("Expression")]);
+
+types.finalize();
+
+},{"./types":119,"ast-types":136,"estraverse":177,"lodash/object/extend":295}],29:[function(require,module,exports){
+"use strict";
+
+module.exports = File;
+
+var sourceMapToComment = require("source-map-to-comment");
+var shebangRegex       = require("shebang-regex");
+var isFunction         = require("lodash/lang/isFunction");
+var transform          = require("./index");
+var generate           = require("../generation");
+var defaults           = require("lodash/object/defaults");
+var includes           = require("lodash/collection/includes");
+var assign             = require("lodash/object/assign");
+var parse              = require("../helpers/parse");
+var Scope              = require("../traversal/scope");
+var slash              = require("slash");
+var util               = require("../util");
+var path               = require("path");
+var each               = require("lodash/collection/each");
+var t                  = require("../types");
+
+function File(opts) {
+  this.dynamicImportedNoDefault = [];
+  this.dynamicImportIds         = {};
+  this.dynamicImported          = [];
+  this.dynamicImports           = [];
+
+  this.dynamicData      = {};
+  this.data             = {};
+
+  this.lastStatements   = [];
+  this.opts             = this.normalizeOptions(opts);
+  this.ast              = {};
+
+  this.buildTransformers();
+}
+
+File.helpers = [
+  "inherits",
+  "defaults",
+  "prototype-properties",
+  "apply-constructor",
+  "tagged-template-literal",
+  "tagged-template-literal-loose",
+  "interop-require",
+  "to-array",
+  "to-consumable-array",
+  "sliced-to-array",
+  "object-without-properties",
+  "has-own",
+  "slice",
+  "bind",
+  "define-property",
+  "async-to-generator",
+  "interop-require-wildcard",
+  "typeof",
+  "extends",
+  "get",
+  "set",
+  "class-call-check",
+  "object-destructuring-empty",
+  "temporal-undefined",
+  "temporal-assert-defined",
+  "self-global"
+];
+
+File.validOptions = [
+  "filename",
+  "filenameRelative",
+  "blacklist",
+  "whitelist",
+  "loose",
+  "optional",
+  "modules",
+  "sourceMap",
+  "sourceMapName",
+  "sourceFileName",
+  "sourceRoot",
+  "moduleRoot",
+  "moduleIds",
+  "comments",
+  "reactCompat",
+  "keepModuleIdExtensions",
+  "code",
+  "ast",
+  "playground",
+  "experimental",
+  "externalHelpers",
+  "auxiliaryComment",
+  "compact",
+
+  "resolveModuleSource",
+  "moduleId",
+
+  // legacy
+  "format",
+
+  // these are used by plugins
+  "ignore",
+  "only",
+  "extensions",
+  "accept"
+];
+
+File.prototype.normalizeOptions = function (opts) {
+  opts = assign({}, opts);
+
+  for (var key in opts) {
+    if (key[0] !== "_" && File.validOptions.indexOf(key) < 0) {
+      throw new ReferenceError("Unknown option: " + key);
+    }
+  }
+
+  defaults(opts, {
+    keepModuleIdExtensions: false,
+    resolveModuleSource:    null,
+    externalHelpers:        false,
+    auxilaryComment:        "",
+    experimental:           false,
+    reactCompat:            false,
+    playground:             false,
+    moduleIds:              false,
+    blacklist:              [],
+    whitelist:              [],
+    sourceMap:              false,
+    optional:               [],
+    comments:               true,
+    filename:               "unknown",
+    modules:                "common",
+    compact:                "auto",
+    loose:                  [],
+    code:                   true,
+    ast:                    true
+  });
+
+  // normalize windows path separators to unix
+  opts.filename = slash(opts.filename);
+  if (opts.sourceRoot) {
+    opts.sourceRoot = slash(opts.sourceRoot);
+  }
+
+  if (opts.moduleId) {
+    opts.moduleIds = true;
+  }
+
+  opts.basename = path.basename(opts.filename, path.extname(opts.filename));
+
+  opts.blacklist = util.arrayify(opts.blacklist);
+  opts.whitelist = util.arrayify(opts.whitelist);
+  opts.optional  = util.arrayify(opts.optional);
+  opts.compact   = util.booleanify(opts.compact);
+  opts.loose     = util.arrayify(opts.loose);
+
+  if (includes(opts.loose, "all") || includes(opts.loose, true)) {
+    opts.loose = Object.keys(transform.transformers);
+  }
+
+  defaults(opts, {
+    moduleRoot: opts.sourceRoot
+  });
+
+  defaults(opts, {
+    sourceRoot: opts.moduleRoot
+  });
+
+  defaults(opts, {
+    filenameRelative: opts.filename
+  });
+
+  defaults(opts, {
+    sourceFileName: opts.filenameRelative,
+    sourceMapName:  opts.filenameRelative
+  });
+
+  if (opts.playground) {
+    opts.experimental = true;
+  }
+
+  if (opts.externalHelpers) {
+    this.set("helpersNamespace", t.identifier("babelHelpers"));
+  }
+
+  opts.blacklist = transform._ensureTransformerNames("blacklist", opts.blacklist);
+  opts.whitelist = transform._ensureTransformerNames("whitelist", opts.whitelist);
+  opts.optional  = transform._ensureTransformerNames("optional", opts.optional);
+  opts.loose     = transform._ensureTransformerNames("loose", opts.loose);
+
+  if (opts.reactCompat) {
+    opts.optional.push("reactCompat");
+    console.error("The reactCompat option has been moved into the optional transformer `reactCompat`");
+  }
+
+  var ensureEnabled = function (key) {
+    var namespace = transform.transformerNamespaces[key];
+    if (namespace === "es7") opts.experimental = true;
+    if (namespace === "playground") opts.playground = true;
+  };
+
+  each(opts.whitelist, ensureEnabled);
+  each(opts.optional, ensureEnabled);
+
+  return opts;
+};
+
+File.prototype.isLoose = function (key) {
+  return includes(this.opts.loose, key);
+};
+
+File.prototype.buildTransformers = function () {
+  var file = this;
+
+  var transformers = {};
+
+  var secondaryStack = [];
+  var stack = [];
+
+  each(transform.transformers, function (transformer, key) {
+    var pass = transformers[key] = transformer.buildPass(file);
+
+    if (pass.canRun(file)) {
+      stack.push(pass);
+
+      if (transformer.secondPass) {
+        secondaryStack.push(pass);
+      }
+
+      if (transformer.manipulateOptions) {
+        transformer.manipulateOptions(file.opts, file);
+      }
+    }
+  });
+
+  this.transformerStack = stack.concat(secondaryStack);
+  this.transformers = transformers;
+};
+
+File.prototype.debug = function (msg) {
+  var parts = this.opts.filename;
+  if (msg) parts += ": " + msg;
+  util.debug(parts);
+};
+
+File.prototype.getModuleFormatter = function (type) {
+  var ModuleFormatter = isFunction(type) ? type : transform.moduleFormatters[type];
+
+  if (!ModuleFormatter) {
+    var loc = util.resolve(type);
+    if (loc) ModuleFormatter = require(loc);
+  }
+
+  if (!ModuleFormatter) {
+    throw new ReferenceError("Unknown module formatter type " + JSON.stringify(type));
+  }
+
+  return new ModuleFormatter(this);
+};
+
+File.prototype.parseShebang = function (code) {
+  var shebangMatch = shebangRegex.exec(code);
+
+  if (shebangMatch) {
+    this.shebang = shebangMatch[0];
+
+    // remove shebang
+    code = code.replace(shebangRegex, "");
+  }
+
+  return code;
+};
+
+File.prototype.set = function (key, val) {
+  return this.data[key] = val;
+};
+
+File.prototype.setDynamic = function (key, fn) {
+  this.dynamicData[key] = fn;
+};
+
+File.prototype.get = function (key) {
+  var data = this.data[key];
+  if (data) {
+    return data;
+  } else {
+    var dynamic = this.dynamicData[key];
+    if (dynamic) {
+      return this.set(key, dynamic());
+    }
+  }
+};
+
+File.prototype.addImport = function (source, name, noDefault) {
+  name = name || source;
+  var id = this.dynamicImportIds[name];
+
+  if (!id) {
+    id = this.dynamicImportIds[name] = this.scope.generateUidIdentifier(name);
+
+    var specifiers = [t.importSpecifier(t.identifier("default"), id)];
+    var declar = t.importDeclaration(specifiers, t.literal(source));
+    declar._blockHoist = 3;
+
+    this.dynamicImported.push(declar);
+    if (noDefault) this.dynamicImportedNoDefault.push(declar);
+
+    this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+  }
+
+  return id;
+};
+
+File.prototype.isConsequenceExpressionStatement = function (node) {
+  return t.isExpressionStatement(node) && this.lastStatements.indexOf(node) >= 0;
+};
+
+File.prototype.attachAuxiliaryComment = function (node) {
+  var comment = this.opts.auxiliaryComment;
+  if (comment) {
+    node.leadingComments = node.leadingComments || [];
+    node.leadingComments.push({
+      type: "Line",
+      value: " " + comment
+    });
+  }
+  return node;
+};
+
+File.prototype.addHelper = function (name) {
+  if (!includes(File.helpers, name)) {
+    throw new ReferenceError("Unknown helper " + name);
+  }
+
+  var program = this.ast.program;
+
+  var declar = program._declarations && program._declarations[name];
+  if (declar) return declar.id;
+
+  var runtime = this.get("helpersNamespace");
+  if (runtime) {
+    name = t.identifier(t.toIdentifier(name));
+    return t.memberExpression(runtime, name);
+  } else {
+    var ref = util.template(name);
+    ref._compact = true;
+    var uid = this.scope.generateUidIdentifier(name);
+    this.scope.push({
+      key: name,
+      id: uid,
+      init: ref
+    });
+    return uid;
+  }
+};
+
+File.prototype.logDeopt = function () {
+  // todo, (node, msg)
+};
+
+File.prototype.errorWithNode = function (node, msg, Error) {
+  Error = Error || SyntaxError;
+
+  var loc = node.loc.start;
+  var err = new Error("Line " + loc.line + ": " + msg);
+  err.loc = loc;
+  return err;
+};
+
+File.prototype.addCode = function (code) {
+  code = (code || "") + "";
+  this.code = code;
+  return this.parseShebang(code);
+};
+
+File.prototype.parse = function (code) {
+  var self = this;
+
+  code = this.addCode(code);
+
+  var opts = this.opts;
+
+  opts.allowImportExportEverywhere = this.isLoose("es6.modules");
+  opts.strictMode = this.transformers.useStrict.canRun();
+
+  return parse(opts, code, function (tree) {
+    self.transform(tree);
+    return self.generate();
+  });
+};
+
+File.prototype.transform = function (ast) {
+  this.debug();
+
+  this.ast = ast;
+  this.lastStatements = t.getLastStatements(ast.program);
+  this.scope = new Scope(ast.program, ast, null, this);
+
+  var modFormatter = this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
+  if (modFormatter.init && this.transformers["es6.modules"].canRun()) {
+    modFormatter.init();
+  }
+
+  this.checkNode(ast);
+
+  this.call("pre");
+
+  each(this.transformerStack, function (pass) {
+    pass.transform();
+  });
+
+  this.call("post");
+};
+
+File.prototype.call = function (key) {
+  var stack = this.transformerStack;
+  for (var i = 0; i < stack.length; i++) {
+    var transformer = stack[i].transformer;
+    if (transformer[key]) {
+      transformer[key](this);
+    }
+  }
+};
+
+var checkTransformerVisitor = {
+  enter: function (node, parent, scope, state) {
+    checkNode(state.stack, node, scope);
+  }
+};
+
+var checkNode = function (stack, node, scope) {
+  each(stack, function (pass) {
+    if (pass.shouldRun) return;
+    pass.checkNode(node, scope);
+  });
+};
+
+File.prototype.checkNode = function (node, scope) {
+  var stack = this.transformerStack;
+  scope = scope || this.scope;
+
+  checkNode(stack, node, scope);
+
+  scope.traverse(node, checkTransformerVisitor, {
+    stack: stack
+  });
+};
+
+File.prototype.generate = function () {
+  var opts = this.opts;
+  var ast  = this.ast;
+
+  var result = {
+    code: "",
+    map: null,
+    ast: null
+  };
+
+  if (opts.ast) result.ast = ast;
+  if (!opts.code) return result;
+
+  var _result = generate(ast, opts, this.code);
+  result.code = _result.code;
+  result.map  = _result.map;
+
+  if (this.shebang) {
+    // add back shebang
+    result.code = this.shebang + "\n" + result.code;
+  }
+
+  if (opts.sourceMap === "inline") {
+    result.code += "\n" + sourceMapToComment(result.map);
+    result.map = null;
+  }
+
+  return result;
+};
+
+},{"../generation":15,"../helpers/parse":25,"../traversal/scope":116,"../types":119,"../util":121,"./index":41,"lodash/collection/each":197,"lodash/collection/includes":200,"lodash/lang/isFunction":286,"lodash/object/assign":293,"lodash/object/defaults":294,"path":146,"shebang-regex":323,"slash":324,"source-map-to-comment":325}],30:[function(require,module,exports){
+"use strict";
+
+var explode = require("./explode-assignable-expression");
+var t       = require("../../types");
+
+module.exports = function (exports, opts) {
+  var isAssignment = function (node) {
+    return node.operator === opts.operator + "=";
+  };
+
+  var buildAssignment = function (left, right) {
+    return t.assignmentExpression("=", left, right);
+  };
+
+  exports.ExpressionStatement = function (node, parent, scope, file) {
+    // hit the `AssignmentExpression` one below
+    if (file.isConsequenceExpressionStatement(node)) return;
+
+    var expr = node.expression;
+    if (!isAssignment(expr)) return;
+
+    var nodes    = [];
+    var exploded = explode(expr.left, nodes, file, scope, true);
+
+    nodes.push(t.expressionStatement(
+      buildAssignment(exploded.ref, opts.build(exploded.uid, expr.right))
+    ));
+
+    return nodes;
+  };
+
+  exports.AssignmentExpression = function (node, parent, scope, file) {
+    if (!isAssignment(node)) return;
+
+    var nodes    = [];
+    var exploded = explode(node.left, nodes, file, scope);
+    nodes.push(buildAssignment(exploded.ref, opts.build(exploded.uid, node.right)));
+
+    return t.toSequenceExpression(nodes, scope);
+  };
+
+  exports.BinaryExpression = function (node) {
+    if (node.operator !== opts.operator) return;
+    return opts.build(node.left, node.right);
+  };
+};
+
+},{"../../types":119,"./explode-assignable-expression":35}],31:[function(require,module,exports){
+"use strict";
+
+var t = require("../../types");
+
+module.exports = function build(node, buildBody) {
+  var self = node.blocks.shift();
+  if (!self) return;
+
+  var child = build(node, buildBody);
+  if (!child) {
+    // last item
+    child = buildBody();
+
+    // add a filter as this is our final stop
+    if (node.filter) {
+      child = t.ifStatement(node.filter, t.blockStatement([child]));
+    }
+  }
+
+  return t.forOfStatement(
+    t.variableDeclaration("let", [t.variableDeclarator(self.left)]),
+    self.right,
+    t.blockStatement([child])
+  );
+};
+
+},{"../../types":119}],32:[function(require,module,exports){
+"use strict";
+
+var explode = require("./explode-assignable-expression");
+var t       = require("../../types");
+
+module.exports = function (exports, opts) {
+  var buildAssignment = function (left, right) {
+    return t.assignmentExpression("=", left, right);
+  };
+
+  exports.ExpressionStatement = function (node, parent, scope, file) {
+    // hit the `AssignmentExpression` one below
+    if (file.isConsequenceExpressionStatement(node)) return;
+
+    var expr = node.expression;
+    if (!opts.is(expr, file)) return;
+
+    var nodes = [];
+
+    var exploded = explode(expr.left, nodes, file, scope);
+
+    nodes.push(t.ifStatement(
+      opts.build(exploded.uid, file),
+      t.expressionStatement(buildAssignment(exploded.ref, expr.right))
+    ));
+
+    return nodes;
+  };
+
+  exports.AssignmentExpression = function (node, parent, scope, file) {
+    if (!opts.is(node, file)) return;
+
+    var nodes    = [];
+    var exploded = explode(node.left, nodes, file, scope);
+
+    nodes.push(t.logicalExpression(
+      "&&",
+      opts.build(exploded.uid, file),
+      buildAssignment(exploded.ref, node.right)
+    ));
+
+    // todo: duplicate expression node
+    nodes.push(exploded.ref);
+
+    return t.toSequenceExpression(nodes, scope);
+  };
+};
+
+},{"../../types":119,"./explode-assignable-expression":35}],33:[function(require,module,exports){
+"use strict";
+
+// Based upon the excellent jsx-transpiler by Ingvar Stepanyan (RReverser)
+// https://github.com/RReverser/jsx-transpiler
+
+// jsx
+
+var isString = require("lodash/lang/isString");
+var messages = require("../../messages");
+var esutils  = require("esutils");
+var react    = require("./react");
+var t        = require("../../types");
+
+module.exports = function (exports, opts) {
+  exports.check = function (node) {
+    if (t.isJSX(node)) return true;
+    if (react.isCreateClass(node)) return true;
+    return false;
+  };
+
+  exports.JSXIdentifier = function (node, parent) {
+    if (node.name === "this" && t.isReferenced(node, parent)) {
+      return t.thisExpression();
+    } else if (esutils.keyword.isIdentifierName(node.name)) {
+      node.type = "Identifier";
+    } else {
+      return t.literal(node.name);
+    }
+  };
+
+  exports.JSXNamespacedName = function (node, parent, scope, file) {
+    throw file.errorWithNode(node, messages.get("JSXNamespacedTags"));
+  };
+
+  exports.JSXMemberExpression = {
+    exit: function (node) {
+      node.computed = t.isLiteral(node.property);
+      node.type = "MemberExpression";
+    }
+  };
+
+  exports.JSXExpressionContainer = function (node) {
+    return node.expression;
+  };
+
+  exports.JSXAttribute = {
+    enter: function (node) {
+      var value = node.value;
+      if (t.isLiteral(value) && isString(value.value)) {
+        value.value = value.value.replace(/\n\s+/g, " ");
+      }
+    },
+
+    exit: function (node) {
+      var value = node.value || t.literal(true);
+      return t.inherits(t.property("init", node.name, value), node);
+    }
+  };
+
+  exports.JSXOpeningElement = {
+    exit: function (node, parent, scope, file) {
+      var tagExpr = node.name;
+      var args = [];
+
+      var tagName;
+      if (t.isIdentifier(tagExpr)) {
+        tagName = tagExpr.name;
+      } else if (t.isLiteral(tagExpr)) {
+        tagName = tagExpr.value;
+      }
+
+      var state = {
+        tagExpr: tagExpr,
+        tagName: tagName,
+        args:    args
+      };
+
+      if (opts.pre) {
+        opts.pre(state, file);
+      }
+
+      var attribs = node.attributes;
+      if (attribs.length) {
+        attribs = buildJSXOpeningElementAttributes(attribs, file);
+      } else {
+        attribs = t.literal(null);
+      }
+
+      args.push(attribs);
+
+      if (opts.post) {
+        opts.post(state, file);
+      }
+
+      return state.call || t.callExpression(state.callee, args);
+    }
+  };
+
+  /**
+   * The logic for this is quite terse. It's because we need to
+   * support spread elements. We loop over all attributes,
+   * breaking on spreads, we then push a new object containg
+   * all prior attributes to an array for later processing.
+   */
+
+  var buildJSXOpeningElementAttributes = function (attribs, file) {
+    var _props = [];
+    var objs = [];
+
+    var pushProps = function () {
+      if (!_props.length) return;
+
+      objs.push(t.objectExpression(_props));
+      _props = [];
+    };
+
+    while (attribs.length) {
+      var prop = attribs.shift();
+      if (t.isJSXSpreadAttribute(prop)) {
+        pushProps();
+        objs.push(prop.argument);
+      } else {
+        _props.push(prop);
+      }
+    }
+
+    pushProps();
+
+    if (objs.length === 1) {
+      // only one object
+      attribs = objs[0];
+    } else {
+      // looks like we have multiple objects
+      if (!t.isObjectExpression(objs[0])) {
+        objs.unshift(t.objectExpression([]));
+      }
+
+      // spread it
+      attribs = t.callExpression(
+        file.addHelper("extends"),
+        objs
+      );
+    }
+
+    return attribs;
+  };
+
+  exports.JSXElement = {
+    exit: function (node) {
+      var callExpr = node.openingElement;
+
+      for (var i = 0; i < node.children.length; i++) {
+        var child = node.children[i];
+
+        if (t.isLiteral(child) && typeof child.value === "string") {
+          cleanJSXElementLiteralChild(child, callExpr.arguments);
+          continue;
+        } else if (t.isJSXEmptyExpression(child)) {
+          continue;
+        }
+
+        callExpr.arguments.push(child);
+      }
+
+      callExpr.arguments = flatten(callExpr.arguments);
+
+      if (callExpr.arguments.length >= 3) {
+        callExpr._prettyCall = true;
+      }
+
+      return t.inherits(callExpr, node);
+    }
+  };
+
+  var isStringLiteral = function (node) {
+    return t.isLiteral(node) && isString(node.value);
+  };
+
+  var flatten = function (args) {
+    var flattened = [];
+    var last;
+
+    for (var i = 0; i < args.length; i++) {
+      var arg = args[i];
+      if (isStringLiteral(arg) && isStringLiteral(last)) {
+        last.value += arg.value;
+      } else {
+        last = arg;
+        flattened.push(arg);
+      }
+    }
+
+    return flattened;
+  };
+
+  var cleanJSXElementLiteralChild = function (child, args) {
+    var lines = child.value.split(/\r\n|\n|\r/);
+
+    var lastNonEmptyLine = 0;
+    var i;
+
+    for (i = 0; i < lines.length; i++) {
+      if (lines[i].match(/[^ \t]/)) {
+        lastNonEmptyLine = i;
+      }
+    }
+
+    for (i = 0; i < lines.length; i++) {
+      var line = lines[i];
+
+      var isFirstLine = i === 0;
+      var isLastLine = i === lines.length - 1;
+      var isLastNonEmptyLine = i === lastNonEmptyLine;
+
+      // replace rendered whitespace tabs with spaces
+      var trimmedLine = line.replace(/\t/g, " ");
+
+      // trim whitespace touching a newline
+      if (!isFirstLine) {
+        trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+      }
+
+      // trim whitespace touching an endline
+      if (!isLastLine) {
+        trimmedLine = trimmedLine.replace(/[ ]+$/, "");
+      }
+
+      if (trimmedLine) {
+        if (!isLastNonEmptyLine) {
+          trimmedLine += " ";
+        }
+
+        args.push(t.literal(trimmedLine));
+      }
+    }
+  };
+
+  // display names
+
+  var addDisplayName = function (id, call) {
+    var props = call.arguments[0].properties;
+    var safe = true;
+
+    for (var i = 0; i < props.length; i++) {
+      var prop = props[i];
+      if (t.isIdentifier(prop.key, { name: "displayName" })) {
+        safe = false;
+        break;
+      }
+    }
+
+    if (safe) {
+      props.unshift(t.property("init", t.identifier("displayName"), t.literal(id)));
+    }
+  };
+
+  exports.ExportDeclaration = function (node, parent, scope, file) {
+    if (node.default && react.isCreateClass(node.declaration)) {
+      addDisplayName(file.opts.basename, node.declaration);
+    }
+  };
+
+  exports.AssignmentExpression =
+  exports.Property =
+  exports.VariableDeclarator = function (node) {
+    var left, right;
+
+    if (t.isAssignmentExpression(node)) {
+      left = node.left;
+      right = node.right;
+    } else if (t.isProperty(node)) {
+      left = node.key;
+      right = node.value;
+    } else if (t.isVariableDeclarator(node)) {
+      left = node.id;
+      right = node.init;
+    }
+
+    if (t.isMemberExpression(left)) {
+      left = left.property;
+    }
+
+    if (t.isIdentifier(left) && react.isCreateClass(right)) {
+      addDisplayName(left.name, right);
+    }
+  };
+};
+
+},{"../../messages":27,"../../types":119,"./react":37,"esutils":181,"lodash/lang/isString":291}],34:[function(require,module,exports){
+var cloneDeep = require("lodash/lang/cloneDeep");
+var traverse  = require("../../traversal");
+var clone     = require("lodash/lang/clone");
+var each      = require("lodash/collection/each");
+var has       = require("lodash/object/has");
+var t         = require("../../types");
+
+exports.push = function (mutatorMap, key, kind, computed, value) {
+  var alias;
+
+  if (t.isIdentifier(key)) {
+    alias = key.name;
+    if (computed) alias = "computed:" + alias;
+  } else if (t.isLiteral(key)) {
+    alias = String(key.value);
+  } else {
+    alias = JSON.stringify(traverse.removeProperties(cloneDeep(key)));
+  }
+
+  var map;
+  if (has(mutatorMap, alias)) {
+    map = mutatorMap[alias];
+  } else {
+    map = {};
+  }
+  mutatorMap[alias] = map;
+
+  map._key = key;
+  if (computed) {
+    map._computed = true;
+  }
+
+  map[kind] = value;
+};
+
+exports.build = function (mutatorMap) {
+  var objExpr = t.objectExpression([]);
+
+  each(mutatorMap, function (map) {
+    var mapNode = t.objectExpression([]);
+
+    var propNode = t.property("init", map._key, mapNode, map._computed);
+
+    if (!map.get && !map.set) {
+      map.writable = t.literal(true);
+    }
+
+    if (map.enumerable === false) {
+      delete map.enumerable;
+    } else {
+      map.enumerable = t.literal(true);
+    }
+
+    map.configurable = t.literal(true);
+
+    each(map, function (node, key) {
+      if (key[0] === "_") return;
+
+      node = clone(node);
+      var inheritNode = node;
+      if (t.isMethodDefinition(node)) node = node.value;
+
+      var prop = t.property("init", t.identifier(key), node);
+      t.inheritsComments(prop, inheritNode);
+      t.removeComments(inheritNode);
+      mapNode.properties.push(prop);
+    });
+
+    objExpr.properties.push(propNode);
+  });
+
+  return objExpr;
+};
+
+},{"../../traversal":114,"../../types":119,"lodash/collection/each":197,"lodash/lang/clone":280,"lodash/lang/cloneDeep":281,"lodash/object/has":296}],35:[function(require,module,exports){
+"use strict";
+
+var t = require("../../types");
+
+var getObjRef = function (node, nodes, file, scope) {
+  var ref;
+  if (t.isIdentifier(node)) {
+    if (scope.hasBinding(node.name)) {
+      // this variable is declared in scope so we can be 100% sure
+      // that evaluating it multiple times wont trigger a getter
+      // or something else
+      return node;
+    } else {
+      // could possibly trigger a getter so we need to only evaluate
+      // it once
+      ref = node;
+    }
+  } else if (t.isMemberExpression(node)) {
+    ref = node.object;
+
+    if (t.isIdentifier(ref) && scope.hasGlobal(ref.name)) {
+      // the object reference that we need to save is locally declared
+      // so as per the previous comment we can be 100% sure evaluating
+      // it multiple times will be safe
+      return ref;
+    }
+  } else {
+    throw new Error("We can't explode this node type " + node.type);
+  }
+
+  var temp = scope.generateUidBasedOnNode(ref);
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(temp, ref)
+  ]));
+  return temp;
+};
+
+var getPropRef = function (node, nodes, file, scope) {
+  var prop = node.property;
+  var key = t.toComputedKey(node, prop);
+  if (t.isLiteral(key)) return key;
+
+  var temp = scope.generateUidBasedOnNode(prop);
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(temp, prop)
+  ]));
+  return temp;
+};
+
+module.exports = function (node, nodes, file, scope, allowedSingleIdent) {
+  var obj;
+  if (t.isIdentifier(node) && allowedSingleIdent) {
+    obj = node;
+  } else {
+    obj = getObjRef(node, nodes, file, scope);
+  }
+
+  var ref, uid;
+
+  if (t.isIdentifier(node)) {
+    ref = node;
+    uid = obj;
+  } else {
+    var prop = getPropRef(node, nodes, file, scope);
+    var computed = node.computed || t.isLiteral(prop);
+    uid = ref = t.memberExpression(obj, prop, computed);
+  }
+
+  return {
+    uid: uid,
+    ref: ref
+  };
+};
+
+},{"../../types":119}],36:[function(require,module,exports){
+"use strict";
+
+var util = require("../../util");
+var t    = require("../../types");
+
+var visitor = {
+  enter: function (node, parent, scope, state) {
+    // check if this node is a referenced identifier that matches the same as our
+    // function id
+    if (!t.isReferencedIdentifier(node, parent, { name: state.name })) return;
+
+    // check that we don't have a local variable declared as that removes the need
+    // for the wrapper
+    var localDeclar = scope.getBindingIdentifier(state.name);
+    if (localDeclar !== state.outerDeclar) return;
+
+    state.selfReference = true;
+    this.stop();
+  }
+};
+
+var wrap = function (state, method, id, scope) {
+  if (state.selfReference) {
+    var templateName = "property-method-assignment-wrapper";
+    if (method.generator) templateName += "-generator";
+    return util.template(templateName, {
+      FUNCTION: method,
+      FUNCTION_ID: id,
+      FUNCTION_KEY: scope.generateUidIdentifier(id.name),
+      WRAPPER_KEY: scope.generateUidIdentifier(id.name + "Wrapper")
+    });
+  } else {
+    method.id = id;
+    return method;
+  }
+};
+
+var visit = function (node, name, scope) {
+  var state = {
+    selfAssignment: false,
+    selfReference:  false,
+    outerDeclar:    scope.getBindingIdentifier(name),
+    references:     [],
+    name:           name,
+  };
+
+  // check to see if we have a local binding of the id we're setting inside of
+  // the function, this is important as there are caveats associated
+
+  var bindingInfo = null; // todo: proper scope not being passed in es6/classes // scope.getOwnBindingInfo(name);
+
+  if (bindingInfo) {
+    if (bindingInfo.kind === "param") {
+      // safari will blow up in strict mode with code like:
+      //
+      //   var t = function t(t) {};
+      //
+      // with the error:
+      //
+      //   Cannot declare a parameter named 't' as it shadows the name of a
+      //   strict mode function.
+      //
+      // this isn't to the spec and they've invented this behaviour which is
+      // **extremely** annoying so we avoid setting the name if it has a param
+      // with the same id
+      state.selfReference = true;
+    } else {
+      // otherwise it's defined somewhere in scope like:
+      //
+      //   var t = function () {
+      //     var t = 2;
+      //   };
+      //
+      // so we can safely just set the id and move along as it shadows the
+      // bound function id
+    }
+  } else {
+    scope.traverse(node, visitor, state);
+  }
+
+  return state;
+};
+
+exports.property = function (node, file, scope) {
+  var key = t.toComputedKey(node, node.key);
+  if (!t.isLiteral(key)) return node; // we can't set a function id with this
+
+  var name = t.toIdentifier(key.value);
+  var id = t.identifier(name);
+
+  var method = node.value;
+  var state  = visit(method, name, scope);
+  node.value = wrap(state, method, id, scope);
+};
+
+exports.bare = function (node, parent, scope) {
+  // has an `id` so we don't need to infer one
+  if (node.id) return;
+
+  var id;
+  if (t.isProperty(parent) && parent.kind === "init" && !parent.computed) {
+    // { foo: function () {} };
+    id = parent.key;
+  } else if (t.isVariableDeclarator(parent)) {
+    // var foo = function () {};
+    id = parent.id;
+  } else {
+    return;
+  }
+
+  if (!t.isIdentifier(id)) return;
+
+  var name = t.toIdentifier(id.name);
+  id = t.identifier(name);
+
+  var state = visit(node, name, scope);
+  return wrap(state, node, id, scope);
+};
+
+},{"../../types":119,"../../util":121}],37:[function(require,module,exports){
+var t = require("../../types");
+
+var isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
+
+exports.isCreateClass = function (node) {
+  if (!node || !t.isCallExpression(node)) return false;
+
+  // not React.createClass call member object
+  if (!isCreateClassCallExpression(node.callee)) return false;
+
+  // no call arguments
+  var args = node.arguments;
+  if (args.length !== 1) return false;
+
+  // first node arg is not an object
+  var first = args[0];
+  if (!t.isObjectExpression(first)) return false;
+
+  return true;
+};
+
+exports.isReactComponent = t.buildMatchMemberExpression("React.Component");
+
+exports.isCompatTag = function (tagName) {
+  return tagName && /^[a-z]|\-/.test(tagName);
+};
+
+},{"../../types":119}],38:[function(require,module,exports){
+"use strict";
+
+var t = require("../../types");
+
+var visitor = {
+  enter: function (node) {
+    if (t.isFunction(node)) this.skip();
+
+    if (t.isAwaitExpression(node)) {
+      node.type = "YieldExpression";
+
+      if (node.all) {
+        // await* foo; -> yield Promise.all(foo);
+        node.all = false;
+        node.argument = t.callExpression(t.memberExpression(t.identifier("Promise"), t.identifier("all")), [node.argument]);
+      }
+    }
+  }
+};
+
+module.exports = function (node, callId, scope) {
+  node.async = false;
+  node.generator = true;
+
+  scope.traverse(node, visitor);
+
+  var call = t.callExpression(callId, [node]);
+  var id = node.id;
+  delete node.id;
+
+  if (t.isFunctionDeclaration(node)) {
+    var declar = t.variableDeclaration("let", [
+      t.variableDeclarator(id, call)
+    ]);
+    declar._blockHoist = true;
+    return declar;
+  } else {
+    return call;
+  }
+};
+
+},{"../../types":119}],39:[function(require,module,exports){
+"use strict";
+
+module.exports = ReplaceSupers;
+
+var messages = require("../../messages");
+var t        = require("../../types");
+
+/**
+ * Description
+ *
+ * @param {Object} opts
+ * @param {Boolean} [inClass]
+ */
+
+function ReplaceSupers(opts, inClass) {
+  this.topLevelThisReference = opts.topLevelThisReference;
+  this.methodNode            = opts.methodNode;
+  this.className             = opts.className;
+  this.superName             = opts.superName;
+  this.isStatic              = opts.isStatic;
+  this.hasSuper              = false;
+  this.inClass               = inClass;
+  this.isLoose               = opts.isLoose;
+  this.scope                 = opts.scope;
+  this.file                  = opts.file;
+}
+
+/**
+ * Sets a super class value of the named property.
+ *
+ * @example
+ *
+ *   _set(Object.getPrototypeOf(CLASS.prototype), "METHOD", "VALUE", this)
+ *
+ * @param {Node} property
+ * @param {Node} value
+ * @param {Boolean} isComputed
+ * @param {Node} thisExpression
+ *
+ * @returns {Node}
+ */
+
+ReplaceSupers.prototype.setSuperProperty = function (property, value, isComputed, thisExpression) {
+  return t.callExpression(
+    this.file.addHelper("set"),
+    [
+      t.callExpression(
+        t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
+        [
+          this.isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+        ]
+      ),
+      isComputed ? property : t.literal(property.name),
+      value,
+      thisExpression
+    ]
+  );
+};
+
+/**
+ * Gets a node representing the super class value of the named property.
+ *
+ * @example
+ *
+ *   _get(Object.getPrototypeOf(CLASS.prototype), "METHOD", this)
+ *
+ * @param {Node} property
+ * @param {Boolean} isComputed
+ * @param {Node} thisExpression
+ *
+ * @returns {Node}
+ */
+
+ReplaceSupers.prototype.getSuperProperty = function (property, isComputed, thisExpression) {
+  return t.callExpression(
+    this.file.addHelper("get"),
+    [
+      t.callExpression(
+        t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
+        [
+          this.isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+        ]
+      ),
+      isComputed ? property : t.literal(property.name),
+      thisExpression
+    ]
+  );
+};
+
+/**
+ * Description
+ */
+
+ReplaceSupers.prototype.replace = function () {
+  this.traverseLevel(this.methodNode.value, true);
+};
+
+var visitor = {
+  enter: function (node, parent, scope, state) {
+    var topLevel = state.topLevel;
+    var self = state.self;
+
+    if (t.isFunction(node) && !t.isArrowFunctionExpression(node)) {
+      // we need to call traverseLevel again so we're context aware
+      self.traverseLevel(node, false);
+      return this.skip();
+    }
+
+    if (t.isProperty(node, { method: true }) || t.isMethodDefinition(node)) {
+      // break on object methods
+      return this.skip();
+    }
+
+    var getThisReference = topLevel ?
+      // top level so `this` is the instance
+      t.thisExpression :
+      // not in the top level so we need to create a reference
+      self.getThisReference.bind(self);
+
+    var callback = self.specHandle;
+    if (self.isLoose) callback = self.looseHandle;
+    return callback.call(self, getThisReference, node, parent);
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Boolean} topLevel
+ */
+
+ReplaceSupers.prototype.traverseLevel = function (node, topLevel) {
+  var state = { self: this, topLevel: topLevel };
+  this.scope.traverse(node, visitor, state);
+};
+
+/**
+ * Description
+ */
+
+ReplaceSupers.prototype.getThisReference = function () {
+  if (this.topLevelThisReference) {
+    return this.topLevelThisReference;
+  } else {
+    var ref = this.topLevelThisReference = this.scope.generateUidIdentifier("this");
+    this.methodNode.value.body.body.unshift(t.variableDeclaration("var", [
+      t.variableDeclarator(this.topLevelThisReference, t.thisExpression())
+    ]));
+    return ref;
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Object} id
+ * @param {Object} parent
+ * @returns {Object}
+ */
+
+ReplaceSupers.prototype.getLooseSuperProperty = function (id, parent) {
+  var methodNode = this.methodNode;
+  var methodName = methodNode.key;
+  var superName  = this.superName || t.identifier("Function");
+
+  if (parent.property === id) {
+    return;
+  } else if (t.isCallExpression(parent, { callee: id })) {
+    // super(); -> ClassName.prototype.MethodName.call(this);
+    parent.arguments.unshift(t.thisExpression());
+
+    if (methodName.name === "constructor") {
+      // constructor() { super(); }
+      return t.memberExpression(superName, t.identifier("call"));
+    } else {
+      id = superName;
+
+      // foo() { super(); }
+      if (!methodNode.static) {
+        id = t.memberExpression(id, t.identifier("prototype"));
+      }
+
+      id = t.memberExpression(id, methodName, methodNode.computed);
+      return t.memberExpression(id, t.identifier("call"));
+    }
+  } else if (t.isMemberExpression(parent) && !methodNode.static) {
+    // super.test -> ClassName.prototype.test
+    return t.memberExpression(superName, t.identifier("prototype"));
+  } else {
+    return superName;
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Function} getThisReference
+ * @param {Object} node
+ * @param {Object} parent
+ */
+
+ReplaceSupers.prototype.looseHandle = function (getThisReference, node, parent) {
+  if (t.isIdentifier(node, { name: "super" })) {
+    this.hasSuper = true;
+    return this.getLooseSuperProperty(node, parent);
+  } else if (t.isCallExpression(node)) {
+    var callee = node.callee;
+    if (!t.isMemberExpression(callee)) return;
+    if (callee.object.name !== "super") return;
+
+    // super.test(); -> ClassName.prototype.MethodName.call(this);
+    this.hasSuper = true;
+    t.appendToMemberExpression(callee, t.identifier("call"));
+    node.arguments.unshift(getThisReference());
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Function} getThisReference
+ * @param {Object} node
+ * @param {Object} parent
+ */
+
+ReplaceSupers.prototype.specHandle = function (getThisReference, node, parent) {
+  var methodNode = this.methodNode;
+  var property;
+  var computed;
+  var args;
+  var thisReference;
+
+  if (isIllegalBareSuper(node, parent)) {
+    throw this.file.errorWithNode(node, messages.get("classesIllegalBareSuper"));
+  }
+
+  if (t.isCallExpression(node)) {
+    var callee = node.callee;
+    if (isSuper(callee, node)) {
+      // super(); -> _get(Object.getPrototypeOf(ClassName), "MethodName", this).call(this);
+      property = methodNode.key;
+      computed = methodNode.computed;
+      args = node.arguments;
+
+      // bare `super` call is illegal inside non-constructors
+      //  - https://esdiscuss.org/topic/super-call-in-methods
+      //  - https://twitter.com/wycats/status/544553184396836864
+      if (methodNode.key.name !== "constructor" || !this.inClass) {
+        var methodName = methodNode.key.name || "METHOD_NAME";
+        throw this.file.errorWithNode(node, messages.get("classesIllegalSuperCall", methodName));
+      }
+    } else if (t.isMemberExpression(callee) && isSuper(callee.object, callee)) {
+      // super.test(); -> _get(Object.getPrototypeOf(ClassName.prototype), "test", this).call(this);
+      property = callee.property;
+      computed = callee.computed;
+      args = node.arguments;
+    }
+  } else if (t.isMemberExpression(node) && isSuper(node.object, node)) {
+    // super.name; -> _get(Object.getPrototypeOf(ClassName.prototype), "name", this);
+    property = node.property;
+    computed = node.computed;
+  } else if (t.isAssignmentExpression(node) && isSuper(node.left.object, node.left) && methodNode.kind === "set") {
+    // super.name = "val"; -> _set(Object.getPrototypeOf(ClassName.prototype), "name", this);
+    this.hasSuper = true;
+    return this.setSuperProperty(node.left.property, node.right, node.left.computed, getThisReference());
+  }
+
+  if (!property) return;
+
+  this.hasSuper = true;
+
+  thisReference = getThisReference();
+  var superProperty = this.getSuperProperty(property, computed, thisReference);
+  if (args) {
+    if (args.length === 1 && t.isSpreadElement(args[0])) {
+      // super(...arguments);
+      return t.callExpression(
+        t.memberExpression(superProperty, t.identifier("apply")),
+        [thisReference, args[0].argument]
+      );
+    } else {
+      return t.callExpression(
+        t.memberExpression(superProperty, t.identifier("call")),
+        [thisReference].concat(args)
+      );
+    }
+  } else {
+    return superProperty;
+  }
+};
+
+var isIllegalBareSuper = function (node, parent) {
+  if (!isSuper(node, parent)) return false;
+  if (t.isMemberExpression(parent, { computed: false })) return false;
+  if (t.isCallExpression(parent, { callee: node })) return false;
+  return true;
+};
+
+var isSuper = function (node, parent) {
+  return t.isIdentifier(node, { name: "super" }) && t.isReferenced(node, parent);
+};
+
+},{"../../messages":27,"../../types":119}],40:[function(require,module,exports){
+"use strict";
+
+var t = require("../../types");
+
+exports.has = function (node) {
+  var first = node.body[0];
+  return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
+};
+
+exports.wrap = function (node, callback) {
+  var useStrictNode;
+  if (exports.has(node)) {
+    useStrictNode = node.body.shift();
+  }
+
+  callback();
+
+  if (useStrictNode) {
+    node.body.unshift(useStrictNode);
+  }
+};
+
+},{"../../types":119}],41:[function(require,module,exports){
+"use strict";
+
+module.exports = transform;
+
+var normalizeAst = require("../helpers/normalize-ast");
+var Transformer  = require("./transformer");
+var object       = require("../helpers/object");
+var File         = require("./file");
+var each         = require("lodash/collection/each");
+
+function transform(code, opts) {
+  var file = new File(opts);
+  return file.parse(code);
+}
+
+transform.fromAst = function (ast, code, opts) {
+  ast = normalizeAst(ast);
+
+  var file = new File(opts);
+  file.addCode(code);
+  file.transform(ast);
+  return file.generate();
+};
+
+transform._ensureTransformerNames = function (type, rawKeys) {
+  var keys = [];
+
+  for (var i = 0; i < rawKeys.length; i++) {
+    var key = rawKeys[i];
+
+    var deprecatedKey = transform.deprecatedTransformerMap[key];
+    if (deprecatedKey) {
+      // deprecated key, remap it to the new one
+      console.error("The transformer " + key + " has been renamed to " + deprecatedKey);
+      rawKeys.push(deprecatedKey);
+    } else if (transform.transformers[key]) {
+      // valid key
+      keys.push(key);
+    } else if (transform.namespaces[key]) {
+      // namespace, append all transformers within this namespace
+      keys = keys.concat(transform.namespaces[key]);
+    } else {
+      // invalid key
+      throw new ReferenceError("Unknown transformer " + key + " specified in " + type);
+    }
+  }
+
+  return keys;
+};
+
+transform.transformerNamespaces = object();
+transform.transformers          = object();
+transform.namespaces            = object();
+
+transform.deprecatedTransformerMap = require("./transformers/deprecated");
+transform.moduleFormatters = require("./modules");
+
+var rawTransformers = require("./transformers");
+
+each(rawTransformers, function (transformer, key) {
+  var namespace = key.split(".")[0];
+
+  transform.namespaces[namespace] = transform.namespaces[namespace] || [];
+  transform.namespaces[namespace].push(key);
+  transform.transformerNamespaces[key] = namespace;
+
+  transform.transformers[key] = new Transformer(key, transformer);
+});
+
+},{"../helpers/normalize-ast":23,"../helpers/object":24,"./file":29,"./modules":49,"./transformer":54,"./transformers":80,"./transformers/deprecated":55,"lodash/collection/each":197}],42:[function(require,module,exports){
+"use strict";
+
+module.exports = DefaultFormatter;
+
+var messages = require("../../messages");
+var extend   = require("lodash/object/extend");
+var object   = require("../../helpers/object");
+var util     = require("../../util");
+var t        = require("../../types");
+
+function DefaultFormatter(file) {
+  this.scope = file.scope;
+  this.file  = file;
+  this.ids   = object();
+
+  this.hasNonDefaultExports = false;
+
+  this.hasLocalExports = false;
+  this.hasLocalImports = false;
+
+  this.localImportOccurences = object();
+  this.localExports = object();
+  this.localImports = object();
+
+  this.getLocalExports();
+  this.getLocalImports();
+
+  this.remapAssignments();
+}
+
+DefaultFormatter.prototype.doDefaultExportInterop = function (node) {
+  return node.default && !this.noInteropRequireExport && !this.hasNonDefaultExports;
+};
+
+DefaultFormatter.prototype.bumpImportOccurences = function (node) {
+  var source = node.source.value;
+  var occurs = this.localImportOccurences;
+  occurs[source] = occurs[source] || 0;
+  occurs[source] += node.specifiers.length;
+};
+
+var exportsVisitor = {
+  enter: function (node, parent, scope, formatter) {
+    var declar = node && node.declaration;
+    if (t.isExportDeclaration(node)) {
+      formatter.hasLocalImports = true;
+
+      if (declar && t.isStatement(declar)) {
+        extend(formatter.localExports, t.getBindingIdentifiers(declar));
+      }
+
+      if (!node.default) {
+        formatter.hasNonDefaultExports = true;
+      }
+
+      if (node.source) {
+        formatter.bumpImportOccurences(node);
+      }
+    }
+  }
+};
+
+DefaultFormatter.prototype.getLocalExports = function () {
+  this.file.scope.traverse(this.file.ast, exportsVisitor, this);
+};
+
+var importsVisitor = {
+  enter: function (node, parent, scope, formatter) {
+    if (t.isImportDeclaration(node)) {
+      formatter.hasLocalImports = true;
+      extend(formatter.localImports, t.getBindingIdentifiers(node));
+      formatter.bumpImportOccurences(node);
+    }
+  }
+};
+
+DefaultFormatter.prototype.getLocalImports = function () {
+  this.file.scope.traverse(this.file.ast, importsVisitor, this);
+};
+
+var remapVisitor = {
+  enter: function (node, parent, scope, formatter) {
+    if (t.isUpdateExpression(node) && formatter.isLocalReference(node.argument, scope)) {
+      this.skip();
+
+      // expand to long file assignment expression
+      var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+      // remap this assignment expression
+      var remapped = formatter.remapExportAssignment(assign);
+
+      // we don't need to change the result
+      if (t.isExpressionStatement(parent) || node.prefix) {
+        return remapped;
+      }
+
+      var nodes = [];
+      nodes.push(remapped);
+
+      var operator;
+      if (node.operator === "--") {
+        operator = "+";
+      } else { // "++"
+        operator = "-";
+      }
+      nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+      return t.sequenceExpression(nodes);
+    }
+
+    if (t.isAssignmentExpression(node) && formatter.isLocalReference(node.left, scope)) {
+      this.skip();
+      return formatter.remapExportAssignment(node);
+    }
+  }
+};
+
+DefaultFormatter.prototype.remapAssignments = function () {
+  if (this.hasLocalImports) {
+    this.file.scope.traverse(this.file.ast, remapVisitor, this);
+  }
+};
+
+DefaultFormatter.prototype.isLocalReference = function (node) {
+  var localImports = this.localImports;
+  return t.isIdentifier(node) && localImports[node.name] && localImports[node.name] !== node;
+};
+
+DefaultFormatter.prototype.remapExportAssignment = function (node) {
+  return t.assignmentExpression(
+    "=",
+    node.left,
+    t.assignmentExpression(
+      node.operator,
+      t.memberExpression(t.identifier("exports"), node.left),
+      node.right
+    )
+  );
+};
+
+DefaultFormatter.prototype.isLocalReference = function (node, scope) {
+  var localExports = this.localExports;
+  var name = node.name;
+  return t.isIdentifier(node) && localExports[name] && localExports[name] === scope.getBindingIdentifier(name);
+};
+
+DefaultFormatter.prototype.getModuleName = function () {
+  var opts = this.file.opts;
+  if (opts.moduleId) return opts.moduleId;
+
+  var filenameRelative = opts.filenameRelative;
+  var moduleName = "";
+
+  if (opts.moduleRoot) {
+    moduleName = opts.moduleRoot + "/";
+  }
+
+  if (!opts.filenameRelative) {
+    return moduleName + opts.filename.replace(/^\//, "");
+  }
+
+  if (opts.sourceRoot) {
+    // remove sourceRoot from filename
+    var sourceRootRegEx = new RegExp("^" + opts.sourceRoot + "\/?");
+    filenameRelative = filenameRelative.replace(sourceRootRegEx, "");
+  }
+
+  if (!opts.keepModuleIdExtensions) {
+    // remove extension
+    filenameRelative = filenameRelative.replace(/\.(\w*?)$/, "");
+  }
+
+  moduleName += filenameRelative;
+
+  // normalize path separators
+  moduleName = moduleName.replace(/\\/g, "/");
+
+  return moduleName;
+};
+
+DefaultFormatter.prototype._pushStatement = function (ref, nodes) {
+  if (t.isClass(ref) || t.isFunction(ref)) {
+    if (ref.id) {
+      nodes.push(t.toStatement(ref));
+      ref = ref.id;
+    }
+  }
+
+  return ref;
+};
+
+DefaultFormatter.prototype._hoistExport = function (declar, assign, priority) {
+  if (t.isFunctionDeclaration(declar)) {
+    assign._blockHoist = priority || 2;
+  }
+
+  return assign;
+};
+
+DefaultFormatter.prototype.getExternalReference = function (node, nodes) {
+  var ids = this.ids;
+  var id = node.source.value;
+
+  if (ids[id]) {
+    return ids[id];
+  } else {
+    return this.ids[id] = this._getExternalReference(node, nodes);
+  }
+};
+
+DefaultFormatter.prototype.checkExportIdentifier = function (node) {
+  if (t.isIdentifier(node, { name: "__esModule" })) {
+    throw this.file.errorWithNode(node, messages.get("modulesIllegalExportName", node.name));
+  }
+};
+
+DefaultFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
+  if (node.source) {
+    var ref = this.getExternalReference(node, nodes);
+
+    if (t.isExportBatchSpecifier(specifier)) {
+      // export * from "foo";
+      nodes.push(this.buildExportsWildcard(ref, node));
+    } else {
+      if (t.isSpecifierDefault(specifier) && !this.noInteropRequireExport) {
+        // importing a default so we need to normalize it
+        ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+      } else {
+        ref = t.memberExpression(ref, t.getSpecifierId(specifier));
+      }
+
+      // export { foo } from "test";
+      nodes.push(this.buildExportsAssignment(
+        t.getSpecifierName(specifier),
+        ref,
+        node
+      ));
+    }
+  } else {
+    // export { foo };
+    nodes.push(this.buildExportsAssignment(t.getSpecifierName(specifier), specifier.id, node));
+  }
+};
+
+DefaultFormatter.prototype.buildExportsWildcard = function (objectIdentifier) {
+  return t.expressionStatement(t.callExpression(this.file.addHelper("defaults"), [
+    t.identifier("exports"),
+    t.callExpression(this.file.addHelper("interop-require-wildcard"), [objectIdentifier])
+  ]));
+};
+
+DefaultFormatter.prototype.buildExportsAssignment = function (id, init) {
+  this.checkExportIdentifier(id);
+  return util.template("exports-assign", {
+    VALUE: init,
+    KEY:   id
+  }, true);
+};
+
+DefaultFormatter.prototype.exportDeclaration = function (node, nodes) {
+  var declar = node.declaration;
+
+  var id = declar.id;
+
+  if (node.default) {
+    id = t.identifier("default");
+  }
+
+  var assign;
+
+  if (t.isVariableDeclaration(declar)) {
+    for (var i = 0; i < declar.declarations.length; i++) {
+      var decl = declar.declarations[i];
+
+      decl.init = this.buildExportsAssignment(decl.id, decl.init, node).expression;
+
+      var newDeclar = t.variableDeclaration(declar.kind, [decl]);
+      if (i === 0) t.inherits(newDeclar, declar);
+      nodes.push(newDeclar);
+    }
+  } else {
+    var ref = declar;
+
+    if (t.isFunctionDeclaration(declar) || t.isClassDeclaration(declar)) {
+      ref = declar.id;
+      nodes.push(declar);
+    }
+
+    assign = this.buildExportsAssignment(id, ref, node);
+
+    nodes.push(assign);
+
+    this._hoistExport(declar, assign);
+  }
+};
+
+},{"../../helpers/object":24,"../../messages":27,"../../types":119,"../../util":121,"lodash/object/extend":295}],43:[function(require,module,exports){
+"use strict";
+
+var util = require("../../util");
+
+module.exports = function (Parent) {
+  var Constructor = function () {
+    this.noInteropRequireImport = true;
+    this.noInteropRequireExport = true;
+    Parent.apply(this, arguments);
+  };
+
+  util.inherits(Constructor, Parent);
+
+  return Constructor;
+};
+
+},{"../../util":121}],44:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./_strict")(require("./amd"));
+
+},{"./_strict":43,"./amd":45}],45:[function(require,module,exports){
+"use strict";
+
+module.exports = AMDFormatter;
+
+var DefaultFormatter = require("./_default");
+var CommonFormatter  = require("./common");
+var includes         = require("lodash/collection/includes");
+var values           = require("lodash/object/values");
+var util             = require("../../util");
+var t                = require("../../types");
+
+function AMDFormatter() {
+  CommonFormatter.apply(this, arguments);
+}
+
+util.inherits(AMDFormatter, DefaultFormatter);
+
+AMDFormatter.prototype.init = CommonFormatter.prototype.init;
+
+AMDFormatter.prototype.buildDependencyLiterals = function () {
+  var names = [];
+  for (var name in this.ids) {
+    names.push(t.literal(name));
+  }
+  return names;
+};
+
+/**
+ * Wrap the entire body in a `define` wrapper.
+ */
+
+AMDFormatter.prototype.transform = function (program) {
+  var body = program.body;
+
+  // build an array of module names
+
+  var names = [t.literal("exports")];
+  if (this.passModuleArg) names.push(t.literal("module"));
+  names = names.concat(this.buildDependencyLiterals());
+  names = t.arrayExpression(names);
+
+  // build up define container
+
+  var params = values(this.ids);
+  if (this.passModuleArg) params.unshift(t.identifier("module"));
+  params.unshift(t.identifier("exports"));
+
+  var container = t.functionExpression(null, params, t.blockStatement(body));
+
+  var defineArgs = [names, container];
+  var moduleName = this.getModuleName();
+  if (moduleName) defineArgs.unshift(t.literal(moduleName));
+
+  var call = t.callExpression(t.identifier("define"), defineArgs);
+
+  program.body = [t.expressionStatement(call)];
+};
+
+/**
+ * Get the AMD module name that we'll prepend to the wrapper
+ * to define this module
+ */
+
+AMDFormatter.prototype.getModuleName = function () {
+  if (this.file.opts.moduleIds) {
+    return DefaultFormatter.prototype.getModuleName.apply(this, arguments);
+  } else {
+    return null;
+  }
+};
+
+AMDFormatter.prototype._getExternalReference = function (node) {
+  return this.scope.generateUidIdentifier(node.source.value);
+};
+
+AMDFormatter.prototype.importDeclaration = function (node) {
+  this.getExternalReference(node);
+};
+
+AMDFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
+  var key = t.getSpecifierName(specifier);
+  var ref = this.getExternalReference(node);
+
+  if (includes(this.file.dynamicImportedNoDefault, node)) {
+    // Prevent unnecessary renaming of dynamic imports.
+    this.ids[node.source.value] = ref;
+  } else if (t.isImportBatchSpecifier(specifier)) {
+    // import * as bar from "foo";
+  } else if (!includes(this.file.dynamicImported, node) && t.isSpecifierDefault(specifier) && !this.noInteropRequireImport) {
+    // import foo from "foo";
+    ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+  } else {
+    // import {foo} from "foo";
+    ref = t.memberExpression(ref, t.getSpecifierId(specifier), false);
+  }
+
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(key, ref)
+  ]));
+};
+
+AMDFormatter.prototype.exportDeclaration = function (node) {
+  if (this.doDefaultExportInterop(node)) {
+    this.passModuleArg = true;
+  }
+
+  CommonFormatter.prototype.exportDeclaration.apply(this, arguments);
+};
+
+},{"../../types":119,"../../util":121,"./_default":42,"./common":47,"lodash/collection/includes":200,"lodash/object/values":299}],46:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./_strict")(require("./common"));
+
+},{"./_strict":43,"./common":47}],47:[function(require,module,exports){
+"use strict";
+
+module.exports = CommonJSFormatter;
+
+var DefaultFormatter = require("./_default");
+var includes         = require("lodash/collection/includes");
+var util             = require("../../util");
+var t                = require("../../types");
+
+function CommonJSFormatter() {
+  DefaultFormatter.apply(this, arguments);
+}
+
+util.inherits(CommonJSFormatter, DefaultFormatter);
+
+CommonJSFormatter.prototype.init = function () {
+  var file  = this.file;
+  var scope = file.scope;
+
+  scope.rename("module");
+
+  if (!this.noInteropRequireImport && this.hasNonDefaultExports) {
+    var templateName = "exports-module-declaration";
+    if (this.file.isLoose("es6.modules")) templateName += "-loose";
+    file.ast.program.body.push(util.template(templateName, true));
+  }
+};
+
+CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
+  var variableName = t.getSpecifierName(specifier);
+
+  var ref = this.getExternalReference(node, nodes);
+
+  // import foo from "foo";
+  if (t.isSpecifierDefault(specifier)) {
+    if (!includes(this.file.dynamicImportedNoDefault, node)) {
+      if (this.noInteropRequireImport || includes(this.file.dynamicImported, node)) {
+        ref = t.memberExpression(ref, t.identifier("default"));
+      } else {
+        ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
+      }
+    }
+    nodes.push(t.variableDeclaration("var", [t.variableDeclarator(variableName, ref)]));
+  } else {
+    if (specifier.type === "ImportBatchSpecifier") {
+
+      if (!this.noInteropRequireImport) {
+        ref = t.callExpression(this.file.addHelper("interop-require-wildcard"), [ref]);
+      }
+
+      // import * as bar from "foo";
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(variableName, ref)
+      ]));
+    } else {
+      // import { foo } from "foo";
+      nodes.push(t.variableDeclaration("var", [
+        t.variableDeclarator(
+          variableName,
+          t.memberExpression(ref, t.getSpecifierId(specifier))
+        )
+      ]));
+    }
+  }
+};
+
+CommonJSFormatter.prototype.importDeclaration = function (node, nodes) {
+  // import "foo";
+  nodes.push(util.template("require", {
+    MODULE_NAME: node.source
+  }, true));
+};
+
+CommonJSFormatter.prototype.exportDeclaration = function (node, nodes) {
+  if (this.doDefaultExportInterop(node)) {
+    var declar = node.declaration;
+    var assign = util.template("exports-default-assign", {
+      VALUE: this._pushStatement(declar, nodes)
+    }, true);
+
+    if (t.isFunctionDeclaration(declar)) {
+      // we can hoist this assignment to the top of the file
+      assign._blockHoist = 3;
+    }
+
+    nodes.push(assign);
+    return;
+  }
+
+  DefaultFormatter.prototype.exportDeclaration.apply(this, arguments);
+};
+
+CommonJSFormatter.prototype._getExternalReference = function (node, nodes) {
+  var source = node.source.value;
+  var call = t.callExpression(t.identifier("require"), [node.source]);
+
+  if (this.localImportOccurences[source] > 1) {
+    var uid = this.scope.generateUidIdentifier(source);
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(uid, call)
+    ]));
+    return uid;
+  } else {
+    return call;
+  }
+};
+
+},{"../../types":119,"../../util":121,"./_default":42,"lodash/collection/includes":200}],48:[function(require,module,exports){
+"use strict";
+
+module.exports = IgnoreFormatter;
+
+var t = require("../../types");
+
+function IgnoreFormatter() {
+
+}
+
+IgnoreFormatter.prototype.exportDeclaration = function (node, nodes) {
+  var declar = t.toStatement(node.declaration, true);
+  if (declar) nodes.push(t.inherits(declar, node));
+};
+
+IgnoreFormatter.prototype.importDeclaration =
+IgnoreFormatter.prototype.importSpecifier =
+IgnoreFormatter.prototype.exportSpecifier = function () {
+
+};
+
+},{"../../types":119}],49:[function(require,module,exports){
+module.exports = {
+  commonStrict: require("./common-strict"),
+  amdStrict:    require("./amd-strict"),
+  umdStrict:    require("./umd-strict"),
+  common:       require("./common"),
+  system:       require("./system"),
+  ignore:       require("./ignore"),
+  amd:          require("./amd"),
+  umd:          require("./umd")
+};
+
+},{"./amd":45,"./amd-strict":44,"./common":47,"./common-strict":46,"./ignore":48,"./system":50,"./umd":52,"./umd-strict":51}],50:[function(require,module,exports){
+"use strict";
+
+module.exports = SystemFormatter;
+
+var DefaultFormatter = require("./_default");
+var AMDFormatter     = require("./amd");
+var util             = require("../../util");
+var last             = require("lodash/array/last");
+var each             = require("lodash/collection/each");
+var map              = require("lodash/collection/map");
+var t                = require("../../types");
+
+function SystemFormatter(file) {
+  this.exportIdentifier = file.scope.generateUidIdentifier("export");
+  this.noInteropRequireExport = true;
+  this.noInteropRequireImport = true;
+
+  DefaultFormatter.apply(this, arguments);
+}
+
+util.inherits(SystemFormatter, AMDFormatter);
+
+SystemFormatter.prototype.init = function () {};
+
+SystemFormatter.prototype._addImportSource = function (node, exportNode) {
+  node._importSource = exportNode.source && exportNode.source.value;
+  return node;
+};
+
+SystemFormatter.prototype.buildExportsWildcard = function (objectIdentifier, node) {
+  var leftIdentifier = this.scope.generateUidIdentifier("key");
+  var valIdentifier  = t.memberExpression(objectIdentifier, leftIdentifier, true);
+
+  var left = t.variableDeclaration("var", [
+    t.variableDeclarator(leftIdentifier)
+  ]);
+
+  var right = objectIdentifier;
+
+  var block = t.blockStatement([
+    t.expressionStatement(this.buildExportCall(leftIdentifier, valIdentifier))
+  ]);
+
+  return this._addImportSource(t.forInStatement(left, right, block), node);
+};
+
+SystemFormatter.prototype.buildExportsAssignment = function (id, init, node) {
+  var call = this.buildExportCall(t.literal(id.name), init, true);
+  return this._addImportSource(call, node);
+};
+
+SystemFormatter.prototype.remapExportAssignment = function (node) {
+  return this.buildExportCall(t.literal(node.left.name), node);
+};
+
+SystemFormatter.prototype.buildExportCall = function (id, init, isStatement) {
+  var call = t.callExpression(this.exportIdentifier, [id, init]);
+  if (isStatement) {
+    return t.expressionStatement(call);
+  } else {
+    return call;
+  }
+};
+
+SystemFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
+  AMDFormatter.prototype.importSpecifier.apply(this, arguments);
+  this._addImportSource(last(nodes), node);
+};
+
+var runnerSettersVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (node._importSource === state.source) {
+      if (t.isVariableDeclaration(node)) {
+        each(node.declarations, function (declar) {
+          state.hoistDeclarators.push(t.variableDeclarator(declar.id));
+          state.nodes.push(t.expressionStatement(
+            t.assignmentExpression("=", declar.id, declar.init)
+          ));
+        });
+      } else {
+        state.nodes.push(node);
+      }
+
+      this.remove();
+    }
+  }
+};
+
+SystemFormatter.prototype.buildRunnerSetters = function (block, hoistDeclarators) {
+  var scope = this.file.scope;
+
+  return t.arrayExpression(map(this.ids, function (uid, source) {
+    var state = {
+      source:           source,
+      nodes:            [],
+      hoistDeclarators: hoistDeclarators
+    };
+
+    scope.traverse(block, runnerSettersVisitor, state);
+
+    return t.functionExpression(null, [uid], t.blockStatement(state.nodes));
+  }));
+};
+
+var hoistVariablesVisitor = {
+  enter: function (node, parent, scope, hoistDeclarators) {
+    if (t.isFunction(node)) {
+      // nothing inside is accessible
+      return this.skip();
+    }
+
+    if (t.isVariableDeclaration(node)) {
+      if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
+        // can't be accessed
+        return;
+      }
+
+      // ignore block hoisted nodes as these can be left in
+      if (node._blockHoist) return;
+
+      var nodes = [];
+
+      for (var i = 0; i < node.declarations.length; i++) {
+        var declar = node.declarations[i];
+        hoistDeclarators.push(t.variableDeclarator(declar.id));
+        if (declar.init) {
+          // no initializer so we can just hoist it as-is
+          var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
+          nodes.push(assign);
+        }
+      }
+
+      // for (var i in test)
+      // for (var i = 0;;)
+      if (t.isFor(parent)) {
+        if (parent.left === node) {
+          return node.declarations[0].id;
+        }
+
+        if (parent.init === node) {
+          return t.toSequenceExpression(nodes, scope);
+        }
+      }
+
+      return nodes;
+    }
+  }
+};
+
+var hoistFunctionsVisitor = {
+  enter: function (node, parent, scope, handlerBody) {
+    if (t.isFunction(node)) this.skip();
+
+    if (t.isFunctionDeclaration(node) || node._blockHoist) {
+      handlerBody.push(node);
+      this.remove();
+    }
+  }
+};
+
+SystemFormatter.prototype.transform = function (program) {
+  var hoistDeclarators = [];
+  var moduleName = this.getModuleName();
+  var moduleNameLiteral = t.literal(moduleName);
+
+  var block = t.blockStatement(program.body);
+
+  var runner = util.template("system", {
+    MODULE_NAME: moduleNameLiteral,
+    MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
+    EXPORT_IDENTIFIER: this.exportIdentifier,
+    SETTERS: this.buildRunnerSetters(block, hoistDeclarators),
+    EXECUTE: t.functionExpression(null, [], block)
+  }, true);
+
+  var handlerBody = runner.expression.arguments[2].body.body;
+  if (!moduleName) runner.expression.arguments.shift();
+
+  var returnStatement = handlerBody.pop();
+
+  // hoist up all variable declarations
+  this.file.scope.traverse(block, hoistVariablesVisitor, hoistDeclarators);
+
+  if (hoistDeclarators.length) {
+    var hoistDeclar = t.variableDeclaration("var", hoistDeclarators);
+    hoistDeclar._blockHoist = true;
+    handlerBody.unshift(hoistDeclar);
+  }
+
+  // hoist up function declarations for circular references
+  this.file.scope.traverse(block, hoistFunctionsVisitor, handlerBody);
+
+  handlerBody.push(returnStatement);
+
+  program.body = [runner];
+};
+
+},{"../../types":119,"../../util":121,"./_default":42,"./amd":45,"lodash/array/last":193,"lodash/collection/each":197,"lodash/collection/map":201}],51:[function(require,module,exports){
+"use strict";
+
+module.exports = require("./_strict")(require("./umd"));
+
+},{"./_strict":43,"./umd":52}],52:[function(require,module,exports){
+"use strict";
+
+module.exports = UMDFormatter;
+
+var AMDFormatter = require("./amd");
+var util         = require("../../util");
+var t            = require("../../types");
+var values       = require("lodash/object/values");
+
+function UMDFormatter() {
+  AMDFormatter.apply(this, arguments);
+}
+
+util.inherits(UMDFormatter, AMDFormatter);
+
+UMDFormatter.prototype.transform = function (program) {
+  var body = program.body;
+
+  // build an array of module names
+
+  var names = [];
+  for (var name in this.ids) {
+    names.push(t.literal(name));
+  }
+
+  // factory
+
+  var ids  = values(this.ids);
+  var args = [t.identifier("exports")];
+  if (this.passModuleArg) args.push(t.identifier("module"));
+  args = args.concat(ids);
+
+  var factory = t.functionExpression(null, args, t.blockStatement(body));
+
+  // amd
+
+  var defineArgs = [t.literal("exports")];
+  if (this.passModuleArg) defineArgs.push(t.literal("module"));
+  defineArgs = defineArgs.concat(names);
+  defineArgs = [t.arrayExpression(defineArgs)];
+
+  // common
+
+  var testExports = util.template("test-exports");
+  var testModule  = util.template("test-module");
+  var commonTests = this.passModuleArg ? t.logicalExpression("&&", testExports, testModule) : testExports;
+
+  var commonArgs = [t.identifier("exports")];
+  if (this.passModuleArg) commonArgs.push(t.identifier("module"));
+  commonArgs = commonArgs.concat(names.map(function (name) {
+    return t.callExpression(t.identifier("require"), [name]);
+  }));
+
+  // globals
+
+  //var umdArgs = [];
+
+  //
+
+  var moduleName = this.getModuleName();
+  if (moduleName) defineArgs.unshift(t.literal(moduleName));
+
+  var runner = util.template("umd-runner-body", {
+    AMD_ARGUMENTS: defineArgs,
+    COMMON_TEST: commonTests,
+    COMMON_ARGUMENTS: commonArgs
+  });
+
+  //
+
+  var call = t.callExpression(runner, [factory]);
+  program.body = [t.expressionStatement(call)];
+};
+
+},{"../../types":119,"../../util":121,"./amd":45,"lodash/object/values":299}],53:[function(require,module,exports){
+module.exports = TransformerPass;
+
+var includes = require("lodash/collection/includes");
+
+/**
+ * This class is responsible for traversing over the provided `File`s
+ * AST and running it's parent transformers handlers over it.
+ */
+
+function TransformerPass(file, transformer) {
+  this.transformer = transformer;
+  this.shouldRun   = !transformer.check;
+  this.handlers    = transformer.handlers;
+  this.file        = file;
+}
+
+TransformerPass.prototype.canRun = function () {
+  var transformer = this.transformer;
+
+  var opts = this.file.opts;
+  var key  = transformer.key;
+
+  // internal
+  if (key[0] === "_") return true;
+
+  // blacklist
+  var blacklist = opts.blacklist;
+  if (blacklist.length && includes(blacklist, key)) return false;
+
+  // whitelist
+  var whitelist = opts.whitelist;
+  if (whitelist.length) return includes(whitelist, key);
+
+  // optional
+  if (transformer.optional && !includes(opts.optional, key)) return false;
+
+  // experimental
+  if (transformer.experimental && !opts.experimental) return false;
+
+  // playground
+  if (transformer.playground && !opts.playground) return false;
+
+  return true;
+};
+
+TransformerPass.prototype.checkNode = function (node) {
+  var check = this.transformer.check;
+  if (check) {
+    return this.shouldRun = check(node);
+  } else {
+    return true;
+  }
+};
+
+TransformerPass.prototype.transform = function () {
+  if (!this.shouldRun) return;
+
+  var file = this.file;
+
+  file.debug("Running transformer " + this.transformer.key);
+
+  file.scope.traverse(file.ast, this.handlers, file);
+};
+
+},{"lodash/collection/includes":200}],54:[function(require,module,exports){
+"use strict";
+
+module.exports = Transformer;
+
+var TransformerPass = require("./transformer-pass");
+var isFunction      = require("lodash/lang/isFunction");
+var traverse        = require("../traversal");
+var isObject        = require("lodash/lang/isObject");
+var assign          = require("lodash/object/assign");
+var each            = require("lodash/collection/each");
+
+/**
+ * This is the class responsible for normalising a transformers handlers
+ * as well as constructing a `TransformerPass` that is repsonsible for
+ * actually running the transformer over the provided `File`.
+ */
+
+function Transformer(key, transformer, opts) {
+  transformer = assign({}, transformer);
+
+  var take = function (key) {
+    var val = transformer[key];
+    delete transformer[key];
+    return val;
+  };
+
+  this.manipulateOptions = take("manipulateOptions");
+  this.check             = take("check");
+  this.post              = take("post");
+  this.pre               = take("pre");
+
+  this.experimental = !!take("experimental");
+  this.playground   = !!take("playground");
+  this.secondPass   = !!take("secondPass");
+  this.optional     = !!take("optional");
+
+  this.handlers = this.normalize(transformer);
+  this.opts     = opts || {};
+  this.key      = key;
+}
+
+Transformer.prototype.normalize = function (transformer) {
+  var self = this;
+
+  if (isFunction(transformer)) {
+    transformer = { ast: transformer };
+  }
+
+  traverse.explode(transformer);
+
+  each(transformer, function (fns, type) {
+    // hidden property
+    if (type[0] === "_") {
+      self[type] = fns;
+      return;
+    }
+
+    if (type === "enter" || type === "exit") return;
+
+    if (isFunction(fns)) fns = { enter: fns };
+
+    if (!isObject(fns)) return;
+
+    if (!fns.enter) fns.enter = function () { };
+    if (!fns.exit) fns.exit = function () { };
+
+    transformer[type] = fns;
+  });
+
+  return transformer;
+};
+
+Transformer.prototype.buildPass = function (file) {
+  return new TransformerPass(file, this);
+};
+
+},{"../traversal":114,"./transformer-pass":53,"lodash/collection/each":197,"lodash/lang/isFunction":286,"lodash/lang/isObject":289,"lodash/object/assign":293}],55:[function(require,module,exports){
+module.exports={
+  "selfContained": "runtime"
+}
+
+},{}],56:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.MemberExpression = function (node) {
+  var prop = node.property;
+  if (node.computed && t.isLiteral(prop) && t.isValidIdentifier(prop.value)) {
+    // foo["bar"] => foo.bar
+    node.property = t.identifier(prop.value);
+    node.computed = false;
+  } else if (!node.computed && t.isIdentifier(prop) && !t.isValidIdentifier(prop.name)) {
+    // foo.default -> foo["default"]
+    node.property = t.literal(prop.name);
+    node.computed = true;
+  }
+};
+
+},{"../../../types":119}],57:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.Property = function (node) {
+  var key = node.key;
+  if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {
+    // "foo": "bar" -> foo: "bar"
+    node.key = t.identifier(key.value);
+    node.computed = false;
+  } else if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
+    // default: "bar" -> "default": "bar"
+    node.key = t.literal(key.name);
+  }
+};
+
+},{"../../../types":119}],58:[function(require,module,exports){
+"use strict";
+
+var defineMap = require("../../helpers/define-map");
+var t         = require("../../../types");
+
+exports.check = function (node) {
+  return t.isProperty(node) && (node.kind === "get" || node.kind === "set");
+};
+
+exports.ObjectExpression = function (node) {
+  var mutatorMap = {};
+  var hasAny = false;
+
+  node.properties = node.properties.filter(function (prop) {
+    if (prop.kind === "get" || prop.kind === "set") {
+      hasAny = true;
+      defineMap.push(mutatorMap, prop.key, prop.kind, prop.computed, prop.value);
+      return false;
+    } else {
+      return true;
+    }
+  });
+
+  if (!hasAny) return;
+
+  return t.callExpression(
+    t.memberExpression(t.identifier("Object"), t.identifier("defineProperties")),
+    [node, defineMap.build(mutatorMap)]
+  );
+};
+
+},{"../../../types":119,"../../helpers/define-map":34}],59:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.check = t.isArrowFunctionExpression;
+
+exports.ArrowFunctionExpression = function (node) {
+  t.ensureBlock(node);
+
+  node._aliasFunction = "arrow";
+  node.expression = false;
+  node.type = "FunctionExpression";
+
+  return node;
+};
+
+},{"../../../types":119}],60:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+var visitor = {
+  enter: function (node, parent, scope, state) {
+    if (!t.isReferencedIdentifier(node, parent)) return;
+
+    var declared = state.letRefs[node.name];
+    if (!declared) return;
+
+    // declared node is different in this scope
+    if (scope.getBindingIdentifier(node.name) !== declared) return;
+
+    var assert = t.callExpression(
+      state.file.addHelper("temporal-assert-defined"),
+      [node, t.literal(node.name), state.file.addHelper("temporal-undefined")]
+    );
+
+    this.skip();
+
+    if (t.isAssignmentExpression(parent) || t.isUpdateExpression(parent)) {
+      if (parent._ignoreBlockScopingTDZ) return;
+      this.parentPath.node = t.sequenceExpression([assert, parent]);
+    } else {
+      return t.logicalExpression("&&", assert, node);
+    }
+  }
+};
+
+exports.optional = true;
+
+exports.Loop =
+exports.Program =
+exports.BlockStatement = function (node, parent, scope, file) {
+  var letRefs = node._letReferences;
+  if (!letRefs) return;
+
+  var state = {
+    letRefs: letRefs,
+    file:    file
+  };
+
+  scope.traverse(node, visitor, state);
+};
+
+},{"../../../types":119}],61:[function(require,module,exports){
+"use strict";
+
+var traverse = require("../../../traversal");
+var object   = require("../../../helpers/object");
+var util     = require("../../../util");
+var t        = require("../../../types");
+var values   = require("lodash/object/values");
+var extend   = require("lodash/object/extend");
+
+exports.check = function (node) {
+  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
+};
+
+var isLet = function (node, parent) {
+  if (!t.isVariableDeclaration(node)) return false;
+  if (node._let) return true;
+  if (node.kind !== "let") return false;
+
+  // https://github.com/babel/babel/issues/255
+  if (isLetInitable(node, parent)) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
+      declar.init = declar.init || t.identifier("undefined");
+    }
+  }
+
+  node._let = true;
+  node.kind = "var";
+  return true;
+};
+
+var isLetInitable = function (node, parent) {
+  return !t.isFor(parent) || !t.isFor(parent, { left: node });
+};
+
+var isVar = function (node, parent) {
+  return t.isVariableDeclaration(node, { kind: "var" }) && !isLet(node, parent);
+};
+
+var standardizeLets = function (declars) {
+  for (var i = 0; i < declars.length; i++) {
+    delete declars[i]._let;
+  }
+};
+
+exports.VariableDeclaration = function (node, parent, scope, file) {
+  if (!isLet(node, parent)) return;
+
+  if (isLetInitable(node) && file.transformers["es6.blockScopingTDZ"].canRun()) {
+    var nodes = [node];
+
+    for (var i = 0; i < node.declarations.length; i++) {
+      var decl = node.declarations[i];
+      if (decl.init) {
+        var assign = t.assignmentExpression("=", decl.id, decl.init);
+        assign._ignoreBlockScopingTDZ = true;
+        nodes.push(t.expressionStatement(assign));
+      }
+      decl.init = file.addHelper("temporal-undefined");
+    }
+
+    node._blockHoist = 2;
+
+    return nodes;
+  }
+};
+
+exports.Loop = function (node, parent, scope, file) {
+  var init = node.left || node.init;
+  if (isLet(init, node)) {
+    t.ensureBlock(node);
+    node.body._letDeclarators = [init];
+  }
+  var blockScoping = new BlockScoping(node, node.body, parent, scope, file);
+  blockScoping.run();
+};
+
+exports.Program =
+exports.BlockStatement = function (block, parent, scope, file) {
+  if (!t.isLoop(parent)) {
+    var blockScoping = new BlockScoping(false, block, parent, scope, file);
+    blockScoping.run();
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Boolean|Node} loopParent
+ * @param {Node} block
+ * @param {Node} parent
+ * @param {Scope} scope
+ * @param {File} file
+ */
+
+function BlockScoping(loopParent, block, parent, scope, file) {
+  this.loopParent = loopParent;
+  this.parent     = parent;
+  this.scope      = scope;
+  this.block      = block;
+  this.file       = file;
+
+  this.outsideLetReferences = object();
+  this.hasLetReferences     = false;
+  this.letReferences        = block._letReferences = object();
+  this.body                 = [];
+}
+
+/**
+ * Start the ball rolling.
+ */
+
+BlockScoping.prototype.run = function () {
+  var block = this.block;
+  if (block._letDone) return;
+  block._letDone = true;
+
+  var needsClosure = this.getLetReferences();
+
+  // this is a block within a `Function/Program` so we can safely leave it be
+  if (t.isFunction(this.parent) || t.isProgram(this.block)) return;
+
+  // we can skip everything
+  if (!this.hasLetReferences) return;
+
+  if (needsClosure) {
+    this.wrapClosure();
+  } else {
+    this.remap();
+  }
+};
+
+function replace(node, parent, scope, remaps) {
+  if (!t.isReferencedIdentifier(node, parent)) return;
+
+  var remap = remaps[node.name];
+  if (!remap) return;
+
+  var ownBinding = scope.getBindingIdentifier(node.name);
+  if (ownBinding === remap.binding) {
+    node.name = remap.uid;
+  } else {
+    // scope already has it's own binding that doesn't
+    // match the one we have a stored replacement for
+    if (this) this.skip();
+  }
+}
+
+var replaceVisitor = {
+  enter: replace
+};
+
+function traverseReplace(node, parent, scope, remaps) {
+  replace(node, parent, scope, remaps);
+  scope.traverse(node, replaceVisitor, remaps);
+}
+
+/**
+ * Description
+ */
+
+BlockScoping.prototype.remap = function () {
+  var hasRemaps = false;
+  var letRefs   = this.letReferences;
+  var scope     = this.scope;
+
+  // alright, so since we aren't wrapping this block in a closure
+  // we have to check if any of our let variables collide with
+  // those in upper scopes and then if they do, generate a uid
+  // for them and replace all references with it
+  var remaps = object();
+
+  for (var key in letRefs) {
+    // just an Identifier node we collected in `getLetReferences`
+    // this is the defining identifier of a declaration
+    var ref = letRefs[key];
+
+    if (scope.parentHasBinding(key) || scope.hasGlobal(key)) {
+      var uid = scope.generateUidIdentifier(ref.name).name;
+      ref.name = uid;
+
+      hasRemaps = true;
+      remaps[key] = remaps[uid] = {
+        binding: ref,
+        uid: uid
+      };
+    }
+  }
+
+  if (!hasRemaps) return;
+
+  //
+
+  var loopParent = this.loopParent;
+  if (loopParent) {
+    traverseReplace(loopParent.right, loopParent, scope, remaps);
+    traverseReplace(loopParent.test, loopParent, scope, remaps);
+    traverseReplace(loopParent.update, loopParent, scope, remaps);
+  }
+
+  scope.traverse(this.block, replaceVisitor, remaps);
+};
+
+/**
+ * Description
+ */
+
+BlockScoping.prototype.wrapClosure = function () {
+  var block = this.block;
+
+  var outsideRefs = this.outsideLetReferences;
+
+  // remap loop heads with colliding variables
+  if (this.loopParent) {
+    for (var name in outsideRefs) {
+      var id = outsideRefs[name];
+
+      if (this.scope.hasGlobal(id.name)) {
+        delete outsideRefs[id.name];
+        delete this.letReferences[id.name];
+
+        this.scope.rename(id.name);
+
+        this.letReferences[id.name] = id;
+        outsideRefs[id.name] = id;
+      }
+    }
+  }
+
+  // if we're inside of a for loop then we search to see if there are any
+  // `break`s, `continue`s, `return`s etc
+  this.has = this.checkLoop();
+
+  // hoist var references to retain scope
+  this.hoistVarDeclarations();
+
+  // turn outsideLetReferences into an array
+  var params = values(outsideRefs);
+
+  // build the closure that we're going to wrap the block with
+  var fn = t.functionExpression(null, params, t.blockStatement(block.body));
+  fn._aliasFunction = true;
+
+  // replace the current block body with the one we're going to build
+  block.body = this.body;
+
+  // build a call and a unique id that we can assign the return value to
+  var call = t.callExpression(fn, params);
+  var ret  = this.scope.generateUidIdentifier("ret");
+
+  // handle generators
+  var hasYield = traverse.hasType(fn.body, this.scope, "YieldExpression", t.FUNCTION_TYPES);
+  if (hasYield) {
+    fn.generator = true;
+    call = t.yieldExpression(call, true);
+  }
+
+  // handlers async functions
+  var hasAsync = traverse.hasType(fn.body, this.scope, "AwaitExpression", t.FUNCTION_TYPES);
+  if (hasAsync) {
+    fn.async = true;
+    call = t.awaitExpression(call, true);
+  }
+
+  this.build(ret, call);
+};
+
+var letReferenceFunctionVisitor = {
+  enter: function (node, parent, scope, state) {
+    // not a direct reference
+    if (!t.isReferencedIdentifier(node, parent)) return;
+
+    // this scope has a variable with the same name so it couldn't belong
+    // to our let scope
+    if (scope.hasOwnBinding(node.name)) return;
+
+    // not a part of our scope
+    if (!state.letReferences[node.name]) return;
+
+    state.closurify = true;
+  }
+};
+
+var letReferenceBlockVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isFunction(node)) {
+      scope.traverse(node, letReferenceFunctionVisitor, state);
+      return this.skip();
+    }
+  }
+};
+
+/**
+ * Description
+ */
+
+BlockScoping.prototype.getLetReferences = function () {
+  var block = this.block;
+
+  var declarators = block._letDeclarators || [];
+  var declar;
+
+  //
+  for (var i = 0; i < declarators.length; i++) {
+    declar = declarators[i];
+    extend(this.outsideLetReferences, t.getBindingIdentifiers(declar));
+  }
+
+  //
+  if (block.body) {
+    for (i = 0; i < block.body.length; i++) {
+      declar = block.body[i];
+      if (isLet(declar, block)) {
+        declarators = declarators.concat(declar.declarations);
+      }
+    }
+  }
+
+  //
+  for (i = 0; i < declarators.length; i++) {
+    declar = declarators[i];
+    var keys = t.getBindingIdentifiers(declar);
+    extend(this.letReferences, keys);
+    this.hasLetReferences = true;
+  }
+
+  // no let references so we can just quit
+  if (!this.hasLetReferences) return;
+
+  // set let references to plain var references
+  standardizeLets(declarators);
+
+  var state = {
+    letReferences: this.letReferences,
+    closurify:     false
+  };
+
+  // traverse through this block, stopping on functions and checking if they
+  // contain any local let references
+  this.scope.traverse(this.block, letReferenceBlockVisitor, state);
+
+  return state.closurify;
+};
+
+var loopNodeTo = function (node) {
+  if (t.isBreakStatement(node)) {
+    return "break";
+  } else if (t.isContinueStatement(node)) {
+    return "continue";
+  }
+};
+
+var loopVisitor = {
+  enter: function (node, parent, scope, state) {
+    var replace;
+
+    if (t.isLoop(node)) {
+      state.ignoreLabeless = true;
+      scope.traverse(node, loopVisitor, state);
+      state.ignoreLabeless = false;
+    }
+
+    if (t.isFunction(node) || t.isLoop(node)) {
+      return this.skip();
+    }
+
+    var loopText = loopNodeTo(node);
+
+    if (loopText) {
+      if (node.label) {
+        // we shouldn't be transforming this because it exists somewhere inside
+        if (state.innerLabels.indexOf(node.label.name) >= 0) {
+          return;
+        }
+
+        loopText = loopText + "|" + node.label.name;
+      } else {
+        // we shouldn't be transforming these statements because
+        // they don't refer to the actual loop we're scopifying
+        if (state.ignoreLabeless) return;
+
+        // break statements mean something different in this context
+        if (t.isBreakStatement(node) && t.isSwitchCase(parent)) return;
+      }
+
+      state.hasBreakContinue = true;
+      state.map[loopText] = node;
+      replace = t.literal(loopText);
+    }
+
+    if (t.isReturnStatement(node)) {
+      state.hasReturn = true;
+      replace = t.objectExpression([
+        t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
+      ]);
+    }
+
+    if (replace) {
+      replace = t.returnStatement(replace);
+      return t.inherits(replace, node);
+    }
+  }
+};
+
+var loopLabelVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isLabeledStatement(node)) {
+      state.innerLabels.push(node.label.name);
+    }
+  }
+};
+
+/**
+ * If we're inside of a loop then traverse it and check if it has one of
+ * the following node types `ReturnStatement`, `BreakStatement`,
+ * `ContinueStatement` and replace it with a return value that we can track
+ * later on.
+ *
+ * @returns {Object}
+ */
+
+BlockScoping.prototype.checkLoop = function () {
+  var state = {
+    hasBreakContinue: false,
+    ignoreLabeless:   false,
+    innerLabels:      [],
+    hasReturn:        false,
+    isLoop:           !!this.loopParent,
+    map:              {}
+  };
+
+  this.scope.traverse(this.block, loopLabelVisitor, state);
+  this.scope.traverse(this.block, loopVisitor, state);
+
+  return state;
+};
+
+var hoistVarDeclarationsVisitor = {
+  enter: function (node, parent, scope, self) {
+    if (t.isForStatement(node)) {
+      if (isVar(node.init, node)) {
+        node.init = t.sequenceExpression(self.pushDeclar(node.init));
+      }
+    } else if (t.isFor(node)) {
+      if (isVar(node.left, node)) {
+        node.left = node.left.declarations[0].id;
+      }
+    } else if (isVar(node, parent)) {
+      return self.pushDeclar(node).map(t.expressionStatement);
+    } else if (t.isFunction(node)) {
+      return this.skip();
+    }
+  }
+};
+
+/**
+ * Hoist all var declarations in this block to before it so they retain scope
+ * once we wrap everything in a closure.
+ */
+
+BlockScoping.prototype.hoistVarDeclarations = function () {
+  traverse(this.block, hoistVarDeclarationsVisitor, this.scope, this);
+};
+
+/**
+ * Turn a `VariableDeclaration` into an array of `AssignmentExpressions` with
+ * their declarations hoisted to before the closure wrapper.
+ *
+ * @param {Node} node VariableDeclaration
+ * @returns {Array}
+ */
+
+BlockScoping.prototype.pushDeclar = function (node) {
+  this.body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
+    return t.variableDeclarator(declar.id);
+  })));
+
+  var replace = [];
+
+  for (var i = 0; i < node.declarations.length; i++) {
+    var declar = node.declarations[i];
+    if (!declar.init) continue;
+
+    var expr = t.assignmentExpression("=", declar.id, declar.init);
+    replace.push(t.inherits(expr, declar));
+  }
+
+  return replace;
+};
+
+/**
+ * Push the closure to the body.
+ *
+ * @param {Node} ret Identifier
+ * @param {Node} call CallExpression
+ */
+
+BlockScoping.prototype.build = function (ret, call) {
+  var has = this.has;
+  if (has.hasReturn || has.hasBreakContinue) {
+    this.buildHas(ret, call);
+  } else {
+    this.body.push(t.expressionStatement(call));
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Node} ret Identifier
+ * @param {Node} call CallExpression
+ */
+
+BlockScoping.prototype.buildHas = function (ret, call) {
+  var body = this.body;
+
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(ret, call)
+  ]));
+
+  var loopParent = this.loopParent;
+  var retCheck;
+  var has = this.has;
+  var cases = [];
+
+  if (has.hasReturn) {
+    // typeof ret === "object"
+    retCheck = util.template("let-scoping-return", {
+      RETURN: ret
+    });
+  }
+
+  if (has.hasBreakContinue) {
+    if (!loopParent) {
+      throw new Error("Has no loop parent but we're trying to reassign breaks " +
+                      "and continues, something is going wrong here.");
+    }
+
+    for (var key in has.map) {
+      cases.push(t.switchCase(t.literal(key), [has.map[key]]));
+    }
+
+    if (has.hasReturn) {
+      cases.push(t.switchCase(null, [retCheck]));
+    }
+
+    if (cases.length === 1) {
+      var single = cases[0];
+      body.push(this.file.attachAuxiliaryComment(t.ifStatement(
+        t.binaryExpression("===", ret, single.test),
+        single.consequent[0]
+      )));
+    } else {
+      body.push(this.file.attachAuxiliaryComment(t.switchStatement(ret, cases)));
+    }
+  } else {
+    if (has.hasReturn) {
+      body.push(this.file.attachAuxiliaryComment(retCheck));
+    }
+  }
+};
+
+},{"../../../helpers/object":24,"../../../traversal":114,"../../../types":119,"../../../util":121,"lodash/object/extend":295,"lodash/object/values":299}],62:[function(require,module,exports){
+"use strict";
+
+var ReplaceSupers = require("../../helpers/replace-supers");
+var nameMethod    = require("../../helpers/name-method");
+var defineMap     = require("../../helpers/define-map");
+var messages      = require("../../../messages");
+var util          = require("../../../util");
+var t             = require("../../../types");
+
+exports.check = t.isClass;
+
+exports.ClassDeclaration = function (node, parent, scope, file) {
+  return new ClassTransformer(node, file, scope, true).run();
+};
+
+exports.ClassExpression = function (node, parent, scope, file) {
+  if (!node.id) {
+    if (t.isProperty(parent) && parent.value === node && !parent.computed && t.isIdentifier(parent.key)) {
+      // var o = { foo: class {} };
+      node.id = parent.key;
+    }
+
+    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+      // var foo = class {};
+      node.id = parent.id;
+    }
+  }
+
+  return new ClassTransformer(node, file, scope, false).run();
+};
+
+/**
+ * Description
+ *
+ * @param {Node} node
+ * @param {File} file
+ * @param {Scope} scope
+ * @param {Boolean} isStatement
+ */
+
+function ClassTransformer(node, file, scope, isStatement) {
+  this.isStatement = isStatement;
+  this.scope       = scope;
+  this.node        = node;
+  this.file        = file;
+
+  this.hasInstanceMutators = false;
+  this.hasStaticMutators   = false;
+
+  this.instanceMutatorMap = {};
+  this.staticMutatorMap   = {};
+  this.hasConstructor     = false;
+  this.className          = node.id || scope.generateUidIdentifier("class");
+  this.superName          = node.superClass || t.identifier("Function");
+  this.hasSuper           = !!node.superClass;
+  this.isLoose            = file.isLoose("es6.classes");
+}
+
+/**
+ * Description
+ *
+ * @returns {Array}
+ */
+
+ClassTransformer.prototype.run = function () {
+  var superName = this.superName;
+  var className = this.className;
+  var classBody = this.node.body.body;
+  var file      = this.file;
+
+  //
+
+  var body = this.body = [];
+
+  var constructorBody = t.blockStatement([
+    t.expressionStatement(t.callExpression(file.addHelper("class-call-check"), [
+      t.thisExpression(),
+      className
+    ]))
+  ]);
+
+  var constructor;
+  if (this.node.id) {
+    constructor = t.functionDeclaration(className, [], constructorBody);
+    body.push(constructor);
+  } else {
+    var constructorName = null;
+    // when a class has no parent and there is only a constructor or no body
+    // then the constructor is not wrapped in a closure and needs to be named
+    var containsOnlyConstructor = classBody.length === 1 && classBody[0].key.name === "constructor";
+    if (!this.hasSuper && (classBody.length === 0 || containsOnlyConstructor)) {
+      constructorName = className;
+    }
+
+    constructor = t.functionExpression(constructorName, [], constructorBody);
+    body.push(t.variableDeclaration("var", [
+      t.variableDeclarator(className, constructor)
+    ]));
+  }
+  this.constructor = constructor;
+
+  var closureParams = [];
+  var closureArgs = [];
+
+  //
+
+  if (this.hasSuper) {
+    closureArgs.push(superName);
+
+    if (!t.isIdentifier(superName)) {
+      superName = this.scope.generateUidBasedOnNode(superName, this.file);
+    }
+
+    closureParams.push(superName);
+
+    this.superName = superName;
+    body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [className, superName])));
+  }
+
+  this.buildBody();
+
+  t.inheritsComments(body[0], this.node);
+
+  var init;
+
+  if (body.length === 1) {
+    // only a constructor so no need for a closure container
+    init = t.toExpression(constructor);
+  } else {
+    body.push(t.returnStatement(className));
+    init = t.callExpression(
+      t.functionExpression(null, closureParams, t.blockStatement(body)),
+      closureArgs
+    );
+  }
+
+  if (this.isStatement) {
+    return t.variableDeclaration("let", [
+      t.variableDeclarator(className, init)
+    ]);
+  } else {
+    return init;
+  }
+};
+
+/**
+ * Description
+ */
+
+ClassTransformer.prototype.buildBody = function () {
+  var constructor = this.constructor;
+  var className   = this.className;
+  var superName   = this.superName;
+  var classBody   = this.node.body.body;
+  var body        = this.body;
+
+  for (var i = 0; i < classBody.length; i++) {
+    var node = classBody[i];
+    if (t.isMethodDefinition(node)) {
+      var replaceSupers = new ReplaceSupers({
+        methodNode: node,
+        className:  this.className,
+        superName:  this.superName,
+        isStatic:   node.static,
+        isLoose:    this.isLoose,
+        scope:      this.scope,
+        file:       this.file
+      }, true);
+      replaceSupers.replace();
+
+      if ((!node.computed && t.isIdentifier(node.key, { name: "constructor" })) || t.isLiteral(node.key, { value: "constructor" })) {
+        this.pushConstructor(node);
+      } else {
+        this.pushMethod(node);
+      }
+    } else if (t.isPrivateDeclaration(node)) {
+      this.closure = true;
+      body.unshift(node);
+    } else if (t.isClassProperty(node)) {
+      this.pushProperty(node);
+    }
+  }
+
+  // we have no constructor, we have a super, and the super doesn't appear to be falsy
+  if (!this.hasConstructor && this.hasSuper && !t.isFalsyExpression(superName)) {
+    var helperName = "class-super-constructor-call";
+    if (this.isLoose) helperName += "-loose";
+    constructor.body.body.push(util.template(helperName, {
+      CLASS_NAME: className,
+      SUPER_NAME: this.superName
+    }, true));
+  }
+
+  var instanceProps;
+  var staticProps;
+
+  if (this.hasInstanceMutators) {
+    instanceProps = defineMap.build(this.instanceMutatorMap);
+  }
+
+  if (this.hasStaticMutators) {
+    staticProps = defineMap.build(this.staticMutatorMap);
+  }
+
+  if (instanceProps || staticProps) {
+    staticProps = staticProps || t.literal(null);
+
+    var args = [className, staticProps];
+    if (instanceProps) args.push(instanceProps);
+
+    body.push(t.expressionStatement(
+      t.callExpression(this.file.addHelper("prototype-properties"), args)
+    ));
+  }
+};
+
+/**
+ * Push a method to its respective mutatorMap.
+ *
+ * @param {Node} node MethodDefinition
+ */
+
+ClassTransformer.prototype.pushMethod = function (node) {
+  var methodName = node.key;
+
+  var kind = node.kind;
+
+  if (kind === "") {
+    nameMethod.property(node, this.file, this.scope);
+
+    if (this.isLoose) {
+      // use assignments instead of define properties for loose classes
+
+      var className = this.className;
+      if (!node.static) className = t.memberExpression(className, t.identifier("prototype"));
+      methodName = t.memberExpression(className, methodName, node.computed);
+
+      var expr = t.expressionStatement(t.assignmentExpression("=", methodName, node.value));
+      t.inheritsComments(expr, node);
+      this.body.push(expr);
+      return;
+    }
+
+    kind = "value";
+  }
+
+  var mutatorMap = this.instanceMutatorMap;
+  if (node.static) {
+    this.hasStaticMutators = true;
+    mutatorMap = this.staticMutatorMap;
+  } else {
+    this.hasInstanceMutators = true;
+  }
+
+  defineMap.push(mutatorMap, methodName, kind, node.computed, node);
+  defineMap.push(mutatorMap, methodName, "enumerable", node.computed, false);
+};
+
+/**
+ * Description
+ *
+ * @param {Node} node
+ */
+
+ClassTransformer.prototype.pushProperty = function (node) {
+  if (!node.value) return;
+
+  var key;
+
+  if (node.static) {
+    key = t.memberExpression(this.className, node.key);
+    this.body.push(
+      t.expressionStatement(t.assignmentExpression("=", key, node.value))
+    );
+  } else {
+    key = t.memberExpression(t.thisExpression(), node.key);
+    this.constructor.body.body.unshift(
+      t.expressionStatement(t.assignmentExpression("=", key, node.value))
+    );
+  }
+};
+
+/**
+ * Replace the constructor body of our class.
+ *
+ * @param {Node} method MethodDefinition
+ */
+
+ClassTransformer.prototype.pushConstructor = function (method) {
+  if (method.kind) {
+    throw this.file.errorWithNode(method, messages.get("classesIllegalConstructorKind"));
+  }
+
+  var construct = this.constructor;
+  var fn        = method.value;
+
+  this.hasConstructor = true;
+
+  t.inherits(construct, fn);
+  t.inheritsComments(construct, method);
+
+  construct._ignoreUserWhitespace = true;
+  construct.params                = fn.params;
+  construct.body.body             = construct.body.body.concat(fn.body.body);
+};
+
+},{"../../../messages":27,"../../../types":119,"../../../util":121,"../../helpers/define-map":34,"../../helpers/name-method":36,"../../helpers/replace-supers":39}],63:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+var t        = require("../../../types");
+
+exports.check = function (node) {
+  return t.isVariableDeclaration(node, { kind: "const" });
+};
+
+var visitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isAssignmentExpression(node) || t.isUpdateExpression(node)) {
+      var ids = t.getBindingIdentifiers(node);
+
+      for (var name in ids) {
+        var id = ids[name];
+
+        var constant = state.constants[name];
+
+        // no constant exists
+        if (!constant) continue;
+
+        var constantIdentifier = constant.identifier;
+
+        // check if the assignment id matches the constant declaration id
+        // if it does then it was the id used to initially declare the
+        // constant so we can just ignore it
+        if (id === constantIdentifier) continue;
+
+        // check if there's been a local binding that shadows this constant
+        if (!scope.bindingIdentifierEquals(name, constantIdentifier)) continue;
+
+        throw state.file.errorWithNode(id, messages.get("readOnly", name));
+      }
+    } else if (t.isScope(node, parent)) {
+      this.skip();
+    }
+  }
+};
+
+exports.Scopable = function (node, parent, scope, file) {
+  scope.traverse(node, visitor, {
+    constants: scope.getAllBindingsOfKind("const"),
+    file:      file
+  });
+};
+
+exports.VariableDeclaration = function (node) {
+  if (node.kind === "const") node.kind = "let";
+};
+
+},{"../../../messages":27,"../../../types":119}],64:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+var t        = require("../../../types");
+
+exports.check = t.isPattern;
+
+function DestructuringTransformer(opts) {
+  this.blockHoist = opts.blockHoist;
+  this.operator   = opts.operator;
+  this.nodes      = opts.nodes;
+  this.scope      = opts.scope;
+  this.file       = opts.file;
+  this.kind       = opts.kind;
+}
+
+DestructuringTransformer.prototype.buildVariableAssignment = function (id, init) {
+  var op = this.operator;
+  if (t.isMemberExpression(id)) op = "=";
+
+  var node;
+
+  if (op) {
+    node = t.expressionStatement(t.assignmentExpression(op, id, init));
+  } else {
+    node = t.variableDeclaration(this.kind, [
+      t.variableDeclarator(id, init)
+    ]);
+  }
+
+  node._blockHoist = this.blockHoist;
+
+  return node;
+};
+
+DestructuringTransformer.prototype.buildVariableDeclaration = function (id, init) {
+  var declar = t.variableDeclaration("var", [
+    t.variableDeclarator(id, init)
+  ]);
+  declar._blockHoist = this.blockHoist;
+  return declar;
+};
+
+DestructuringTransformer.prototype.push = function (id, init) {
+  if (t.isObjectPattern(id)) {
+    this.pushObjectPattern(id, init);
+  } else if (t.isArrayPattern(id)) {
+    this.pushArrayPattern(id, init);
+  } else if (t.isAssignmentPattern(id)) {
+    this.pushAssignmentPattern(id, init);
+  } else {
+    this.nodes.push(this.buildVariableAssignment(id, init));
+  }
+};
+
+DestructuringTransformer.prototype.get = function () {
+
+};
+
+DestructuringTransformer.prototype.pushAssignmentPattern = function (pattern, valueRef) {
+  // we need to assign the current value of the assignment to avoid evaluating
+  // it more than once
+
+  var tempValueRef = this.scope.generateUidBasedOnNode(valueRef);
+
+  var declar = t.variableDeclaration("var", [
+    t.variableDeclarator(tempValueRef, valueRef)
+  ]);
+  declar._blockHoist = this.blockHoist;
+  this.nodes.push(declar);
+
+  //
+
+  this.nodes.push(this.buildVariableAssignment(
+    pattern.left,
+    t.conditionalExpression(
+      t.binaryExpression("===", tempValueRef, t.identifier("undefined")),
+      pattern.right,
+      tempValueRef
+    )
+  ));
+};
+
+DestructuringTransformer.prototype.pushObjectSpread = function (pattern, objRef, spreadProp, spreadPropIndex) {
+  // get all the keys that appear in this object before the current spread
+
+  var keys = [];
+
+  for (var i = 0; i < pattern.properties.length; i++) {
+    var prop = pattern.properties[i];
+
+    // we've exceeded the index of the spread property to all properties to the
+    // right need to be ignored
+    if (i >= spreadPropIndex) break;
+
+    // ignore other spread properties
+    if (t.isSpreadProperty(prop)) continue;
+
+    var key = prop.key;
+    if (t.isIdentifier(key)) key = t.literal(prop.key.name);
+    keys.push(key);
+  }
+
+  keys = t.arrayExpression(keys);
+
+  //
+
+  var value = t.callExpression(this.file.addHelper("object-without-properties"), [objRef, keys]);
+  this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
+};
+
+DestructuringTransformer.prototype.pushObjectProperty = function (prop, propRef) {
+  if (t.isLiteral(prop.key)) prop.computed = true;
+
+  var pattern = prop.value;
+  var objRef  = t.memberExpression(propRef, prop.key, prop.computed);
+
+  if (t.isPattern(pattern)) {
+    this.push(pattern, objRef);
+  } else {
+    this.nodes.push(this.buildVariableAssignment(pattern, objRef));
+  }
+};
+
+DestructuringTransformer.prototype.pushObjectPattern = function (pattern, objRef) {
+  // https://github.com/babel/babel/issues/681
+
+  if (!pattern.properties.length) {
+    this.nodes.push(t.expressionStatement(
+      t.callExpression(this.file.addHelper("object-destructuring-empty"), [objRef])
+    ));
+  }
+
+  // if we have more than one properties in this pattern and the objectRef is a
+  // member expression then we need to assign it to a temporary variable so it's
+  // only evaluated once
+
+  if (pattern.properties.length > 1 && t.isMemberExpression(objRef)) {
+    var temp = this.scope.generateUidBasedOnNode(objRef, this.file);
+    this.nodes.push(this.buildVariableDeclaration(temp, objRef));
+    objRef = temp;
+  }
+
+  //
+
+  for (var i = 0; i < pattern.properties.length; i++) {
+    var prop = pattern.properties[i];
+    if (t.isSpreadProperty(prop)) {
+      this.pushObjectSpread(pattern, objRef, prop, i);
+    } else {
+      this.pushObjectProperty(prop, objRef);
+    }
+  }
+};
+
+var hasRest = function (pattern) {
+  for (var i = 0; i < pattern.elements.length; i++) {
+    if (t.isRestElement(pattern.elements[i])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+DestructuringTransformer.prototype.canUnpackArrayPattern = function (pattern, arr) {
+  // not an array so there's no way we can deal with this
+  if (!t.isArrayExpression(arr)) return false;
+
+  // pattern has less elements than the array and doesn't have a rest so some
+  // elements wont be evaluated
+  if (pattern.elements.length > arr.elements.length) return;
+  if (pattern.elements.length < arr.elements.length && !hasRest(pattern)) return false;
+
+  // deopt on holes
+  for (var i = 0; i < pattern.elements.length; i++) {
+    if (!pattern.elements[i]) return false;
+  }
+
+  return true;
+};
+
+DestructuringTransformer.prototype.pushUnpackedArrayPattern = function (pattern, arr) {
+  for (var i = 0; i < pattern.elements.length; i++) {
+    var elem = pattern.elements[i];
+    if (t.isRestElement(elem)) {
+      this.push(elem.argument, t.arrayExpression(arr.elements.slice(i)));
+    } else {
+      this.push(elem, arr.elements[i]);
+    }
+  }
+};
+
+DestructuringTransformer.prototype.pushArrayPattern = function (pattern, arrayRef) {
+  if (!pattern.elements) return;
+
+  // optimise basic array destructuring of an array expression
+  //
+  // we can't do this to a pattern of unequal size to it's right hand
+  // array expression as then there will be values that wont be evaluated
+  //
+  // eg: var [a, b] = [1, 2];
+
+  if (this.canUnpackArrayPattern(pattern, arrayRef)) {
+    return this.pushUnpackedArrayPattern(pattern, arrayRef);
+  }
+
+  // if we have a rest then we need all the elements so don't tell
+  // `scope.toArray` to only get a certain amount
+
+  var count = !hasRest(pattern) && pattern.elements.length;
+
+  // so we need to ensure that the `arrayRef` is an array, `scope.toArray` will
+  // return a locally bound identifier if it's been inferred to be an array,
+  // otherwise it'll be a call to a helper that will ensure it's one
+
+  var toArray = this.scope.toArray(arrayRef, count);
+
+  if (t.isIdentifier(toArray)) {
+    // we've been given an identifier so it must have been inferred to be an
+    // array
+    arrayRef = toArray;
+  } else {
+    arrayRef = this.scope.generateUidBasedOnNode(arrayRef);
+    this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
+    this.scope.assignTypeGeneric(arrayRef.name, "Array");
+  }
+
+  //
+
+  for (var i = 0; i < pattern.elements.length; i++) {
+    var elem = pattern.elements[i];
+
+    // hole
+    if (!elem) continue;
+
+    var elemRef;
+
+    if (t.isRestElement(elem)) {
+      elemRef = this.scope.toArray(arrayRef);
+
+      if (i > 0) {
+        elemRef = t.callExpression(t.memberExpression(elemRef, t.identifier("slice")), [t.literal(i)]);
+      }
+
+      // set the element to the rest element argument since we've dealt with it
+      // being a rest already
+      elem = elem.argument;
+    } else {
+      elemRef = t.memberExpression(arrayRef, t.literal(i), true);
+    }
+
+    this.push(elem, elemRef);
+  }
+};
+
+DestructuringTransformer.prototype.init = function (pattern, ref) {
+  // trying to destructure a value that we can't evaluate more than once so we
+  // need to save it to a variable
+
+  if (!t.isArrayExpression(ref) && !t.isMemberExpression(ref) && !t.isIdentifier(ref)) {
+    var key = this.scope.generateUidBasedOnNode(ref);
+    this.nodes.push(this.buildVariableDeclaration(key, ref));
+    ref = key;
+  }
+
+  //
+
+  this.push(pattern, ref);
+};
+
+exports.ForInStatement =
+exports.ForOfStatement = function (node, parent, scope, file) {
+  var left = node.left;
+
+  if (t.isPattern(left)) {
+    // for ({ length: k } in { abc: 3 });
+
+    var temp = scope.generateUidIdentifier("ref");
+
+    node.left = t.variableDeclaration("var", [
+      t.variableDeclarator(temp)
+    ]);
+
+    t.ensureBlock(node);
+
+    node.body.body.unshift(t.variableDeclaration("var", [
+      t.variableDeclarator(left, temp)
+    ]));
+
+    return;
+  }
+
+  if (!t.isVariableDeclaration(left)) return;
+
+  var pattern = left.declarations[0].id;
+  if (!t.isPattern(pattern)) return;
+
+  var key = scope.generateUidIdentifier("ref");
+  node.left = t.variableDeclaration(left.kind, [
+    t.variableDeclarator(key, null)
+  ]);
+
+  var nodes = [];
+
+  var destructuring = new DestructuringTransformer({
+    kind: left.kind,
+    file: file,
+    scope: scope,
+    nodes: nodes
+  });
+
+  destructuring.init(pattern, key);
+
+  t.ensureBlock(node);
+
+  var block = node.body;
+  block.body = nodes.concat(block.body);
+};
+
+exports.Function = function (node, parent, scope, file) {
+  var nodes = [];
+
+  var hasDestructuringTransformer = false;
+
+  node.params = node.params.map(function (pattern, i) {
+    if (!t.isPattern(pattern)) return pattern;
+
+    hasDestructuringTransformer = true;
+    var ref = scope.generateUidIdentifier("ref");
+
+    var destructuring = new DestructuringTransformer({
+      blockHoist: node.params.length - i,
+      nodes:      nodes,
+      scope:      scope,
+      file:       file,
+      kind:       "var",
+    });
+    destructuring.init(pattern, ref);
+
+    return ref;
+  });
+
+  if (!hasDestructuringTransformer) return;
+
+  t.ensureBlock(node);
+
+  var block = node.body;
+  block.body = nodes.concat(block.body);
+};
+
+exports.CatchClause = function (node, parent, scope, file) {
+  var pattern = node.param;
+  if (!t.isPattern(pattern)) return;
+
+  var ref = scope.generateUidIdentifier("ref");
+  node.param = ref;
+
+  var nodes = [];
+
+  var destructuring = new DestructuringTransformer({
+    kind: "let",
+    file: file,
+    scope: scope,
+    nodes: nodes
+  });
+  destructuring.init(pattern, ref);
+
+  node.body.body = nodes.concat(node.body.body);
+
+  return node;
+};
+
+exports.ExpressionStatement = function (node, parent, scope, file) {
+  var expr = node.expression;
+  if (expr.type !== "AssignmentExpression") return;
+  if (!t.isPattern(expr.left)) return;
+  if (file.isConsequenceExpressionStatement(node)) return;
+
+  var nodes = [];
+
+  var ref = scope.generateUidIdentifier("ref");
+  nodes.push(t.variableDeclaration("var", [
+    t.variableDeclarator(ref, expr.right)
+  ]));
+
+  var destructuring = new DestructuringTransformer({
+    operator: expr.operator,
+    file: file,
+    scope: scope,
+    nodes: nodes
+  });
+  destructuring.init(expr.left, ref);
+
+  return nodes;
+};
+
+exports.AssignmentExpression = function (node, parent, scope, file) {
+  if (!t.isPattern(node.left)) return;
+
+  var ref = scope.generateUidIdentifier("temp");
+  scope.push({
+    key: ref.name,
+    id: ref
+  });
+
+  var nodes = [];
+  nodes.push(t.assignmentExpression("=", ref, node.right));
+
+  var destructuring = new DestructuringTransformer({
+    operator: node.operator,
+    file: file,
+    scope: scope,
+    nodes: nodes
+  });
+  destructuring.init(node.left, ref);
+
+  nodes.push(ref);
+
+  return t.toSequenceExpression(nodes, scope);
+};
+
+var variableDeclarationHasPattern = function (node) {
+  for (var i = 0; i < node.declarations.length; i++) {
+    if (t.isPattern(node.declarations[i].id)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+exports.VariableDeclaration = function (node, parent, scope, file) {
+  if (t.isForInStatement(parent) || t.isForOfStatement(parent)) return;
+  if (!variableDeclarationHasPattern(node)) return;
+
+  var nodes = [];
+  var declar;
+
+  for (var i = 0; i < node.declarations.length; i++) {
+    declar = node.declarations[i];
+
+    var patternId = declar.init;
+    var pattern   = declar.id;
+
+    var destructuring = new DestructuringTransformer({
+      nodes: nodes,
+      scope: scope,
+      kind:  node.kind,
+      file:  file
+    });
+
+    if (t.isPattern(pattern) && patternId) {
+      destructuring.init(pattern, patternId);
+
+      if (+i !== node.declarations.length - 1) {
+        // we aren't the last declarator so let's just make the
+        // last transformed node inherit from us
+        t.inherits(nodes[nodes.length - 1], declar);
+      }
+    } else {
+      nodes.push(t.inherits(destructuring.buildVariableAssignment(declar.id, declar.init), declar));
+    }
+  }
+
+  if (!t.isProgram(parent) && !t.isBlockStatement(parent)) {
+    // https://github.com/babel/babel/issues/113
+    // for (let [x] = [0]; false;) {}
+
+    declar = null;
+
+    for (i = 0; i < nodes.length; i++) {
+      node = nodes[i];
+      declar = declar || t.variableDeclaration(node.kind, []);
+
+      if (!t.isVariableDeclaration(node) && declar.kind !== node.kind) {
+        throw file.errorWithNode(node, messages.get("invalidParentForThisNode"));
+      }
+
+      declar.declarations = declar.declarations.concat(node.declarations);
+    }
+
+    return declar;
+  }
+
+  return nodes;
+};
+
+},{"../../../messages":27,"../../../types":119}],65:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+var util     = require("../../../util");
+var t        = require("../../../types");
+
+exports.check = t.isForOfStatement;
+
+exports.ForOfStatement = function (node, parent, scope, file) {
+  var callback = spec;
+  if (file.isLoose("es6.forOf")) callback = loose;
+
+  var build  = callback(node, parent, scope, file);
+  var declar = build.declar;
+  var loop   = build.loop;
+  var block  = loop.body;
+
+  // inherit comments from the original loop
+  t.inheritsComments(loop, node);
+
+  // ensure that it's a block so we can take all its statements
+  t.ensureBlock(node);
+
+  // add the value declaration to the new loop body
+  if (declar) {
+    block.body.push(declar);
+  }
+
+  // push the rest of the original loop body onto our new body
+  block.body = block.body.concat(node.body.body);
+
+  t.inherits(loop, node);
+
+  // todo: find out why this is necessary? #538
+  loop._scopeInfo = node._scopeInfo;
+
+  return loop;
+};
+
+var breakVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isLoop(node)) {
+      state.ignoreLabeless = true;
+      scope.traverse(node, breakVisitor, state);
+      state.ignoreLabeless = false;
+      return this.skip();
+    }
+
+    if (t.isBreakStatement(node)) {
+      if (!node.label && state.ignoreLabeless) return;
+      if (node.label && node.label.name !== state.label) return;
+
+      var ret = t.expressionStatement(
+        t.callExpression(t.memberExpression(state.iteratorKey, t.identifier("return")), [])
+      );
+      ret = state.wrapReturn(ret);
+
+      this.skip();
+      return [ret, node];
+    }
+  }
+};
+
+var loose = function (node, parent, scope, file) {
+  var left = node.left;
+  var declar, id;
+
+  if (t.isIdentifier(left) || t.isPattern(left) || t.isMemberExpression(left)) {
+    // for (i of test), for ({ i } of test)
+    id = left;
+  } else if (t.isVariableDeclaration(left)) {
+    // for (var i of test)
+    id = scope.generateUidIdentifier("ref");
+    declar = t.variableDeclaration(left.kind, [
+      t.variableDeclarator(left.declarations[0].id, id)
+    ]);
+  } else {
+    throw file.errorWithNode(left, messages.get("unknownForHead", left.type));
+  }
+
+  var iteratorKey = scope.generateUidIdentifier("iterator");
+  var isArrayKey  = scope.generateUidIdentifier("isArray");
+
+  var loop = util.template("for-of-loose", {
+    LOOP_OBJECT:  iteratorKey,
+    IS_ARRAY:     isArrayKey,
+    OBJECT:       node.right,
+    INDEX:        scope.generateUidIdentifier("i"),
+    ID:           id
+  });
+
+  if (!declar) {
+    // no declaration so we need to remove the variable declaration at the top of
+    // the for-of-loose template
+    loop.body.body.shift();
+  }
+
+  //
+
+  scope.traverse(node, breakVisitor, {
+    iteratorKey: iteratorKey,
+    wrapReturn:  function (node) {
+      return t.ifStatement(
+        t.logicalExpression(
+          "&&",
+          t.unaryExpression("!", isArrayKey, true),
+          t.memberExpression(iteratorKey, t.identifier("return")
+        )
+      ), node);
+    },
+    label:       t.isLabeledStatement(parent) && parent.label.name
+  });
+
+  //
+
+  return {
+    declar: declar,
+    loop:   loop
+  };
+};
+
+var spec = function (node, parent, scope, file) {
+  var left = node.left;
+  var declar;
+
+  var stepKey   = scope.generateUidIdentifier("step");
+  var stepValue = t.memberExpression(stepKey, t.identifier("value"));
+
+  if (t.isIdentifier(left) || t.isPattern(left) || t.isMemberExpression(left)) {
+    // for (i of test), for ({ i } of test)
+    declar = t.expressionStatement(t.assignmentExpression("=", left, stepValue));
+  } else if (t.isVariableDeclaration(left)) {
+    // for (var i of test)
+    declar = t.variableDeclaration(left.kind, [
+      t.variableDeclarator(left.declarations[0].id, stepValue)
+    ]);
+  } else {
+    throw file.errorWithNode(left, messages.get("unknownForHead", left.type));
+  }
+
+  //
+
+  var iteratorKey = scope.generateUidIdentifier("iterator");
+
+  var loop = util.template("for-of", {
+    ITERATOR_KEY: iteratorKey,
+    STEP_KEY:     stepKey,
+    OBJECT:       node.right
+  });
+
+  //
+
+  scope.traverse(node, breakVisitor, {
+    iteratorKey: iteratorKey,
+    wrapReturn:  function (node) {
+      return t.ifStatement(t.memberExpression(iteratorKey, t.identifier("return")), node);
+    },
+    label:       t.isLabeledStatement(parent) && parent.label.name
+  });
+
+  //
+
+  return {
+    declar: declar,
+    loop:   loop
+  };
+};
+
+},{"../../../messages":27,"../../../types":119,"../../../util":121}],66:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.check = require("../internal/modules").check;
+
+exports.ImportDeclaration = function (node, parent, scope, file) {
+  // flow type
+  if (node.isType) return;
+
+  var nodes = [];
+
+  if (node.specifiers.length) {
+    for (var i = 0; i < node.specifiers.length; i++) {
+      file.moduleFormatter.importSpecifier(node.specifiers[i], node, nodes, parent);
+    }
+  } else {
+    file.moduleFormatter.importDeclaration(node, nodes, parent);
+  }
+
+  if (nodes.length === 1) {
+    // inherit `_blockHoist` - this is for `_blockHoist` in File.prototype.addImport
+    nodes[0]._blockHoist = node._blockHoist;
+  }
+
+  return nodes;
+};
+
+exports.ExportDeclaration = function (node, parent, scope, file) {
+  // flow type
+  if (t.isTypeAlias(node.declaration)) return;
+
+  var nodes = [];
+  var i;
+
+  if (node.declaration) {
+    // make sure variable exports have an initializer
+    // this is done here to avoid duplicating it in the module formatters
+    if (t.isVariableDeclaration(node.declaration)) {
+      var declar = node.declaration.declarations[0];
+      declar.init = declar.init || t.identifier("undefined");
+    }
+
+    file.moduleFormatter.exportDeclaration(node, nodes, parent);
+  } else if (node.specifiers) {
+    for (i = 0; i < node.specifiers.length; i++) {
+      file.moduleFormatter.exportSpecifier(node.specifiers[i], node, nodes, parent);
+    }
+  }
+
+  if (node._blockHoist) {
+    for (i = 0; i < nodes.length; i++) {
+      nodes[i]._blockHoist = node._blockHoist;
+    }
+  }
+
+  return nodes;
+};
+
+},{"../../../types":119,"../internal/modules":86}],67:[function(require,module,exports){
+"use strict";
+
+var ReplaceSupers = require("../../helpers/replace-supers");
+var t             = require("../../../types");
+
+exports.check = function (node) {
+  return t.isIdentifier(node, { name: "super" });
+};
+
+exports.Property = function (node, parent, scope, file) {
+  if (!node.method) return;
+
+  var value = node.value;
+  var thisExpr = scope.generateUidIdentifier("this");
+
+  var replaceSupers = new ReplaceSupers({
+    topLevelThisReference: thisExpr,
+    methodNode:            node,
+    className:             thisExpr,
+    isStatic:              true,
+    scope:                 scope,
+    file:                  file
+  });
+
+  replaceSupers.replace();
+
+  if (replaceSupers.hasSuper) {
+    value.body.body.unshift(
+      t.variableDeclaration("var", [
+        t.variableDeclarator(thisExpr, t.thisExpression())
+      ])
+    );
+  }
+};
+
+},{"../../../types":119,"../../helpers/replace-supers":39}],68:[function(require,module,exports){
+"use strict";
+
+var util = require("../../../util");
+var t    = require("../../../types");
+
+exports.check = function (node) {
+  return t.isFunction(node) && hasDefaults(node);
+};
+
+var hasDefaults = function (node) {
+  for (var i = 0; i < node.params.length; i++) {
+    if (!t.isIdentifier(node.params[i])) return true;
+  }
+  return false;
+};
+
+var iifeVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (!t.isReferencedIdentifier(node, parent)) return;
+    if (!state.scope.hasOwnBinding(node.name)) return;
+    if (state.scope.bindingIdentifierEquals(node.name, node)) return;
+
+    state.iife = true;
+    this.stop();
+  }
+};
+
+exports.Function = function (node, parent, scope, file) {
+  if (!hasDefaults(node)) return;
+
+  t.ensureBlock(node);
+
+  var body = [];
+
+  var argsIdentifier = t.identifier("arguments");
+  argsIdentifier._ignoreAliasFunctions = true;
+
+  var lastNonDefaultParam = 0;
+
+  var state = { iife: false, scope: scope };
+
+  var pushDefNode = function (left, right, i) {
+    var defNode = util.template("default-parameter", {
+      VARIABLE_NAME: left,
+      DEFAULT_VALUE: right,
+      ARGUMENT_KEY:  t.literal(i),
+      ARGUMENTS:     argsIdentifier
+    }, true);
+    file.checkNode(defNode);
+    defNode._blockHoist = node.params.length - i;
+    body.push(defNode);
+  };
+
+  for (var i = 0; i < node.params.length; i++) {
+    var param = node.params[i];
+
+    if (!t.isAssignmentPattern(param)) {
+      if (!t.isRestElement(param)) {
+        lastNonDefaultParam = i + 1;
+      }
+
+      if (!t.isIdentifier(param)) {
+        scope.traverse(param, iifeVisitor, state);
+      }
+
+      if (file.transformers["es6.blockScopingTDZ"].canRun()) {
+        pushDefNode(param, t.identifier("undefined"), i);
+      }
+
+      continue;
+    }
+
+    var left  = param.left;
+    var right = param.right;
+
+    var placeholder = scope.generateUidIdentifier("x");
+    placeholder._isDefaultPlaceholder = true;
+    node.params[i] = placeholder;
+
+    if (!state.iife) {
+      if (t.isIdentifier(right) && scope.hasOwnBinding(right.name)) {
+        state.iife = true;
+      } else {
+        scope.traverse(right, iifeVisitor, state);
+      }
+    }
+
+    pushDefNode(left, right, i);
+  }
+
+  // we need to cut off all trailing default parameters
+  node.params = node.params.slice(0, lastNonDefaultParam);
+
+  if (state.iife) {
+    var container = t.functionExpression(null, [], node.body, node.generator);
+    container._aliasFunction = true;
+
+    body.push(t.returnStatement(t.callExpression(container, [])));
+
+    node.body = t.blockStatement(body);
+  } else {
+    node.body.body = body.concat(node.body.body);
+  }
+};
+
+},{"../../../types":119,"../../../util":121}],69:[function(require,module,exports){
+"use strict";
+
+var util = require("../../../util");
+var t    = require("../../../types");
+
+exports.check = t.isRestElement;
+
+var hasRest = function (node) {
+  return t.isRestElement(node.params[node.params.length - 1]);
+};
+
+exports.Function = function (node, parent, scope) {
+  if (!hasRest(node)) return;
+
+  var rest = node.params.pop().argument;
+
+  var argsId = t.identifier("arguments");
+
+  // otherwise `arguments` will be remapped in arrow functions
+  argsId._ignoreAliasFunctions = true;
+
+  var start = t.literal(node.params.length);
+  var key = scope.generateUidIdentifier("key");
+  var len = scope.generateUidIdentifier("len");
+
+  var arrKey = key;
+  var arrLen = len;
+  if (node.params.length) {
+    // this method has additional params, so we need to subtract
+    // the index of the current argument position from the
+    // position in the array that we want to populate
+    arrKey = t.binaryExpression("-", key, start);
+
+    // we need to work out the size of the array that we're
+    // going to store all the rest parameters
+    //
+    // we need to add a check to avoid constructing the array
+    // with <0 if there are less arguments than params as it'll
+    // cause an error
+    arrLen = t.conditionalExpression(
+      t.binaryExpression(">", len, start),
+      t.binaryExpression("-", len, start),
+      t.literal(0)
+    );
+  }
+
+  // support patterns
+  if (t.isPattern(rest)) {
+    var pattern = rest;
+    rest = scope.generateUidIdentifier("ref");
+
+    // let the destructuring transformer handle this
+    var restDeclar = t.variableDeclaration("var", [
+      t.variableDeclarator(pattern, rest)
+    ]);
+
+    // retain evaluation position
+    restDeclar._blockHoist = node.params.length + 1;
+
+    node.body.body.unshift(restDeclar);
+  }
+
+  scope.assignTypeGeneric(rest.name, "Array");
+
+  var loop = util.template("rest", {
+    ARGUMENTS: argsId,
+    ARRAY_KEY: arrKey,
+    ARRAY_LEN: arrLen,
+    START: start,
+    ARRAY: rest,
+    KEY: key,
+    LEN: len,
+  });
+  loop._blockHoist = node.params.length + 1;
+  node.body.body.unshift(loop);
+};
+
+},{"../../../types":119,"../../../util":121}],70:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.check = function (node) {
+  return t.isProperty(node) && node.computed;
+};
+
+exports.ObjectExpression = function (node, parent, scope, file) {
+  var hasComputed = false;
+
+  for (var i = 0; i < node.properties.length; i++) {
+    hasComputed = t.isProperty(node.properties[i], { computed: true, kind: "init" });
+    if (hasComputed) break;
+  }
+
+  if (!hasComputed) return;
+
+  var initProps = [];
+  var objId = scope.generateUidBasedOnNode(parent);
+
+  //
+
+  var body = [];
+  var container = t.functionExpression(null, [], t.blockStatement(body));
+  container._aliasFunction = true;
+
+  //
+
+  var callback = spec;
+  if (file.isLoose("es6.properties.computed")) callback = loose;
+
+  var result = callback(node, body, objId, initProps, file);
+  if (result) return result;
+
+  //
+
+  body.unshift(t.variableDeclaration("var", [
+    t.variableDeclarator(objId, t.objectExpression(initProps))
+  ]));
+
+  body.push(t.returnStatement(objId));
+
+  return t.callExpression(container, []);
+};
+
+var loose = function (node, body, objId) {
+  for (var i = 0; i < node.properties.length; i++) {
+    var prop = node.properties[i];
+
+    body.push(t.expressionStatement(
+      t.assignmentExpression(
+        "=",
+        t.memberExpression(objId, prop.key, prop.computed || t.isLiteral(prop.key)),
+        prop.value
+      )
+    ));
+  }
+};
+
+var spec = function (node, body, objId, initProps, file) {
+  var props = node.properties;
+  var prop, key;
+
+  // normalize key
+
+  for (var i = 0; i < props.length; i++) {
+    prop = props[i];
+    if (prop.kind !== "init") continue;
+
+    key = prop.key;
+
+    if (!prop.computed && t.isIdentifier(key)) {
+      prop.key = t.literal(key.name);
+    }
+  }
+
+  // add all non-computed properties and `__proto__` properties to the initializer
+
+  var broken = false;
+
+  for (i = 0; i < props.length; i++) {
+    prop = props[i];
+
+    if (prop.computed) {
+      broken = true;
+    }
+
+    if (prop.kind !== "init" || !broken || t.isLiteral(t.toComputedKey(prop, prop.key), { value: "__proto__" })) {
+      initProps.push(prop);
+      props[i] = null;
+    }
+  }
+
+  // add a simple assignment for all Symbol member expressions due to symbol polyfill limitations
+  // otherwise use Object.defineProperty
+
+  for (i = 0; i < props.length; i++) {
+    prop = props[i];
+    if (!prop) continue;
+
+    key = prop.key;
+    var bodyNode;
+
+    if (prop.computed && t.isMemberExpression(key) && t.isIdentifier(key.object, { name: "Symbol" })) {
+      // { [Symbol.iterator]: "foo" }
+      bodyNode = t.assignmentExpression(
+        "=",
+        t.memberExpression(objId, key, true),
+        prop.value
+      );
+    } else {
+      bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
+    }
+
+    body.push(t.expressionStatement(bodyNode));
+  }
+
+  // only one node and it's a Object.defineProperty that returns the object
+
+  if (body.length === 1) {
+    var first = body[0].expression;
+
+    if (t.isCallExpression(first)) {
+      first.arguments[0] = t.objectExpression(initProps);
+      return first;
+    }
+  }
+};
+
+},{"../../../types":119}],71:[function(require,module,exports){
+"use strict";
+
+var clone = require("lodash/lang/clone");
+var t     = require("../../../types");
+
+exports.check = function (node) {
+  return t.isProperty(node) && (node.method || node.shorthand);
+};
+
+exports.Property = function (node) {
+  if (node.method) {
+    node.method = false;
+  }
+
+  if (node.shorthand) {
+    node.shorthand = false;
+    node.key = t.removeComments(clone(node.key));
+  }
+};
+
+},{"../../../types":119,"lodash/lang/clone":280}],72:[function(require,module,exports){
+"use strict";
+
+var includes = require("lodash/collection/includes");
+var t        = require("../../../types");
+
+exports.check = t.isSpreadElement;
+
+var getSpreadLiteral = function (spread, scope) {
+  return scope.toArray(spread.argument, true);
+};
+
+var hasSpread = function (nodes) {
+  for (var i = 0; i < nodes.length; i++) {
+    if (t.isSpreadElement(nodes[i])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+var build = function (props, scope) {
+  var nodes = [];
+
+  var _props = [];
+
+  var push = function () {
+    if (!_props.length) return;
+    nodes.push(t.arrayExpression(_props));
+    _props = [];
+  };
+
+  for (var i = 0; i < props.length; i++) {
+    var prop = props[i];
+    if (t.isSpreadElement(prop)) {
+      push();
+      nodes.push(getSpreadLiteral(prop, scope));
+    } else {
+      _props.push(prop);
+    }
+  }
+
+  push();
+
+  return nodes;
+};
+
+exports.ArrayExpression = function (node, parent, scope) {
+  var elements = node.elements;
+  if (!hasSpread(elements)) return;
+
+  var nodes = build(elements, scope);
+  var first = nodes.shift();
+
+  if (!t.isArrayExpression(first)) {
+    nodes.unshift(first);
+    first = t.arrayExpression([]);
+  }
+
+  return t.callExpression(t.memberExpression(first, t.identifier("concat")), nodes);
+};
+
+exports.CallExpression = function (node, parent, scope) {
+  var args = node.arguments;
+  if (!hasSpread(args)) return;
+
+  var contextLiteral = t.identifier("undefined");
+
+  node.arguments = [];
+
+  var nodes;
+  if (args.length === 1 && args[0].argument.name === "arguments") {
+    nodes = [args[0].argument];
+  } else {
+    nodes = build(args, scope);
+  }
+
+  var first = nodes.shift();
+  if (nodes.length) {
+    node.arguments.push(t.callExpression(t.memberExpression(first, t.identifier("concat")), nodes));
+  } else {
+    node.arguments.push(first);
+  }
+
+  var callee = node.callee;
+
+  if (t.isMemberExpression(callee)) {
+    var temp = scope.generateTempBasedOnNode(callee.object);
+    if (temp) {
+      callee.object = t.assignmentExpression("=", temp, callee.object);
+      contextLiteral = temp;
+    } else {
+      contextLiteral = callee.object;
+    }
+    t.appendToMemberExpression(callee, t.identifier("apply"));
+  } else {
+    node.callee = t.memberExpression(node.callee, t.identifier("apply"));
+  }
+
+  node.arguments.unshift(contextLiteral);
+};
+
+exports.NewExpression = function (node, parent, scope, file) {
+  var args = node.arguments;
+  if (!hasSpread(args)) return;
+
+  var nativeType = t.isIdentifier(node.callee) && includes(t.NATIVE_TYPE_NAMES, node.callee.name);
+
+  var nodes = build(args, scope);
+
+  if (nativeType) {
+    nodes.unshift(t.arrayExpression([t.literal(null)]));
+  }
+
+  var first = nodes.shift();
+
+  if (nodes.length) {
+    args = t.callExpression(t.memberExpression(first, t.identifier("concat")), nodes);
+  } else {
+    args = first;
+  }
+
+  if (nativeType) {
+    return t.newExpression(
+      t.callExpression(
+        t.memberExpression(file.addHelper("bind"), t.identifier("apply")),
+        [node.callee, args]
+      ),
+      []
+    );
+  } else {
+    return t.callExpression(file.addHelper("apply-constructor"), [node.callee, args]);
+  }
+};
+
+},{"../../../types":119,"lodash/collection/includes":200}],73:[function(require,module,exports){
+"use strict";
+
+var reduceRight = require("lodash/collection/reduceRight");
+var messages    = require("../../../messages");
+var flatten     = require("lodash/array/flatten");
+var util        = require("../../../util");
+var map         = require("lodash/collection/map");
+var t           = require("../../../types");
+
+function returnBlock(expr) {
+  return t.blockStatement([t.returnStatement(expr)]);
+}
+
+function TailCallTransformer(node, scope, file) {
+  this.hasTailRecursion = false;
+  this.needsArguments   = false;
+  this.setsArguments    = false;
+  this.needsThis        = false;
+  this.ownerId          = node.id;
+  this.vars             = [];
+
+  this.scope = scope;
+  this.file  = file;
+  this.node  = node;
+}
+
+TailCallTransformer.prototype.getArgumentsId = function () {
+  return this.argumentsId = this.argumentsId || this.scope.generateUidIdentifier("arguments");
+};
+
+TailCallTransformer.prototype.getThisId = function () {
+  return this.thisId = this.thisId || this.scope.generateUidIdentifier("this");
+};
+
+TailCallTransformer.prototype.getLeftId = function () {
+  return this.leftId = this.leftId || this.scope.generateUidIdentifier("left");
+};
+
+TailCallTransformer.prototype.getFunctionId = function () {
+  return this.functionId = this.functionId || this.scope.generateUidIdentifier("function");
+};
+
+TailCallTransformer.prototype.getAgainId = function () {
+  return this.againId = this.againId || this.scope.generateUidIdentifier("again");
+};
+
+TailCallTransformer.prototype.getParams = function () {
+  var params = this.params;
+
+  if (!params) {
+    params = this.node.params;
+    this.paramDecls = [];
+
+    for (var i = 0; i < params.length; i++) {
+      var param = params[i];
+      if (!param._isDefaultPlaceholder) {
+        this.paramDecls.push(t.variableDeclarator(
+          param,
+          params[i] = this.scope.generateUidIdentifier("x")
+        ));
+      }
+    }
+  }
+
+  return this.params = params;
+};
+
+TailCallTransformer.prototype.hasDeopt = function () {
+  // check if the ownerId has been reassigned, if it has then it's not safe to
+  // perform optimisations
+  var ownerIdInfo = this.scope.getBindingInfo(this.ownerId.name);
+  return ownerIdInfo && ownerIdInfo.reassigned;
+};
+
+TailCallTransformer.prototype.run = function () {
+  var scope = this.scope;
+  var node  = this.node;
+
+  // only tail recursion can be optimized as for now, so we can skip anonymous
+  // functions entirely
+  var ownerId = this.ownerId;
+  if (!ownerId) return;
+
+  // traverse the function and look for tail recursion
+  scope.traverse(node, firstPass, this);
+
+  if (!this.hasTailRecursion) return;
+
+  if (this.hasDeopt()) {
+    this.file.logDeopt(node, messages.get("tailCallReassignmentDeopt"));
+    return;
+  }
+
+  //
+
+  scope.traverse(node, secondPass, this);
+
+  if (!this.needsThis || !this.needsArguments) {
+    scope.traverse(node, thirdPass, this);
+  }
+
+  var body = t.ensureBlock(node).body;
+
+  if (this.vars.length > 0) {
+    var declarations = flatten(map(this.vars, function (decl) {
+      return decl.declarations;
+    }, this));
+    var statement = reduceRight(declarations, function (expr, decl) {
+      return t.assignmentExpression("=", decl.id, expr);
+    }, t.identifier("undefined"));
+    body.unshift(t.expressionStatement(statement));
+  }
+
+  var paramDecls = this.paramDecls;
+  if (paramDecls.length > 0) {
+    body.unshift(t.variableDeclaration("var", paramDecls));
+  }
+
+  body.unshift(t.expressionStatement(
+    t.assignmentExpression("=", this.getAgainId(), t.literal(false)))
+  );
+
+  node.body = util.template("tail-call-body", {
+    AGAIN_ID:      this.getAgainId(),
+    THIS_ID:       this.thisId,
+    ARGUMENTS_ID:  this.argumentsId,
+    FUNCTION_ID:   this.getFunctionId(),
+    BLOCK:         node.body
+  });
+
+  var topVars = [];
+
+  if (this.needsThis) {
+    topVars.push(t.variableDeclarator(this.getThisId(), t.thisExpression()));
+  }
+
+  if (this.needsArguments || this.setsArguments) {
+    var decl = t.variableDeclarator(this.getArgumentsId());
+    if (this.needsArguments) {
+      decl.init = t.identifier("arguments");
+    }
+    topVars.push(decl);
+  }
+
+  var leftId = this.leftId;
+  if (leftId) {
+    topVars.push(t.variableDeclarator(leftId));
+  }
+
+  if (topVars.length > 0) {
+    node.body.body.unshift(t.variableDeclaration("var", topVars));
+  }
+};
+
+TailCallTransformer.prototype.subTransform = function (node) {
+  if (!node) return;
+
+  var handler = this["subTransform" + node.type];
+  if (handler) return handler.call(this, node);
+};
+
+TailCallTransformer.prototype.subTransformConditionalExpression = function (node) {
+  var callConsequent = this.subTransform(node.consequent);
+  var callAlternate = this.subTransform(node.alternate);
+  if (!callConsequent && !callAlternate) {
+    return;
+  }
+
+  // if ternary operator had tail recursion in value, convert to optimized if-statement
+  node.type = "IfStatement";
+  node.consequent = callConsequent ? t.toBlock(callConsequent) : returnBlock(node.consequent);
+
+  if (callAlternate) {
+    node.alternate = t.isIfStatement(callAlternate) ? callAlternate : t.toBlock(callAlternate);
+  } else {
+    node.alternate = returnBlock(node.alternate);
+  }
+
+  return [node];
+};
+
+TailCallTransformer.prototype.subTransformLogicalExpression = function (node) {
+  // only call in right-value of can be optimized
+  var callRight = this.subTransform(node.right);
+  if (!callRight) return;
+
+  // cache left value as it might have side-effects
+  var leftId = this.getLeftId();
+  var testExpr = t.assignmentExpression(
+    "=",
+    leftId,
+    node.left
+  );
+
+  if (node.operator === "&&") {
+    testExpr = t.unaryExpression("!", testExpr);
+  }
+
+  return [t.ifStatement(testExpr, returnBlock(leftId))].concat(callRight);
+};
+
+TailCallTransformer.prototype.subTransformSequenceExpression = function (node) {
+  var seq = node.expressions;
+
+  // only last element can be optimized
+  var lastCall = this.subTransform(seq[seq.length - 1]);
+  if (!lastCall) {
+    return;
+  }
+
+  // remove converted expression from sequence
+  // and convert to regular expression if needed
+  if (--seq.length === 1) {
+    node = seq[0];
+  }
+
+  return [t.expressionStatement(node)].concat(lastCall);
+};
+
+TailCallTransformer.prototype.subTransformCallExpression = function (node) {
+  var callee = node.callee, thisBinding, args;
+
+  if (t.isMemberExpression(callee, { computed: false }) && t.isIdentifier(callee.property)) {
+    switch (callee.property.name) {
+      case "call":
+        args = t.arrayExpression(node.arguments.slice(1));
+        break;
+
+      case "apply":
+        args = node.arguments[1] || t.identifier("undefined");
+        break;
+
+      default:
+        return;
+    }
+
+    thisBinding = node.arguments[0];
+    callee = callee.object;
+  }
+
+  // only tail recursion can be optimized as for now
+  if (!t.isIdentifier(callee) || !this.scope.bindingIdentifierEquals(callee.name, this.ownerId)) {
+    return;
+  }
+
+  this.hasTailRecursion = true;
+
+  if (this.hasDeopt()) return;
+
+  var body = [];
+
+  if (!t.isThisExpression(thisBinding)) {
+    body.push(t.expressionStatement(t.assignmentExpression(
+      "=",
+      this.getThisId(),
+      thisBinding || t.identifier("undefined")
+    )));
+  }
+
+  if (!args) {
+    args = t.arrayExpression(node.arguments);
+  }
+
+  var argumentsId = this.getArgumentsId();
+  var params = this.getParams();
+
+  body.push(t.expressionStatement(t.assignmentExpression(
+    "=",
+    argumentsId,
+    args
+  )));
+
+  var i, param;
+
+  if (t.isArrayExpression(args)) {
+    var elems = args.elements;
+    for (i = 0; i < elems.length && i < params.length; i++) {
+      param = params[i];
+      var elem = elems[i] || (elems[i] = t.identifier("undefined"));
+      if (!param._isDefaultPlaceholder) {
+        elems[i] = t.assignmentExpression("=", param, elem);
+      }
+    }
+  } else {
+    this.setsArguments = true;
+    for (i = 0; i < params.length; i++) {
+      param = params[i];
+      if (!param._isDefaultPlaceholder) {
+        body.push(t.expressionStatement(t.assignmentExpression(
+          "=",
+          param,
+          t.memberExpression(argumentsId, t.literal(i), true)
+        )));
+      }
+    }
+  }
+
+  body.push(t.expressionStatement(
+    t.assignmentExpression("=", this.getAgainId(), t.literal(true))
+  ));
+  body.push(t.continueStatement(this.getFunctionId()));
+
+  return body;
+};
+
+// looks for and replaces tail recursion calls
+var firstPass = {
+  enter: function (node, parent, scope, state) {
+    if (t.isIfStatement(node)) {
+      if (t.isReturnStatement(node.alternate)) {
+        t.ensureBlock(node, "alternate");
+      }
+
+      if (t.isReturnStatement(node.consequent)) {
+        t.ensureBlock(node, "consequent");
+      }
+    } else if (t.isReturnStatement(node)) {
+      this.skip();
+      return state.subTransform(node.argument);
+    } else if (t.isTryStatement(parent)) {
+      if (node === parent.block) {
+        this.skip();
+      } else if (parent.finalizer && node !== parent.finalizer) {
+        this.skip();
+      }
+    } else if (t.isFunction(node)) {
+      this.skip();
+    } else if (t.isVariableDeclaration(node)) {
+      this.skip();
+      state.vars.push(node);
+    }
+  }
+};
+
+// hoists up function declarations, replaces `this` and `arguments` and marks
+// them as needed
+var secondPass = {
+  enter: function (node, parent, scope, state) {
+    if (t.isThisExpression(node)) {
+      state.needsThis = true;
+      return state.getThisId();
+    } else if (t.isReferencedIdentifier(node, parent, { name: "arguments" })) {
+      state.needsArguments = true;
+      return state.getArgumentsId();
+    } else if (t.isFunction(node)) {
+      this.skip();
+      if (t.isFunctionDeclaration(node)) {
+        node = t.variableDeclaration("var", [
+          t.variableDeclarator(node.id, t.toExpression(node))
+        ]);
+        node._blockHoist = 2;
+        return node;
+      }
+    }
+  }
+};
+
+// optimizes recursion by removing `this` and `arguments` if they aren't used
+var thirdPass = {
+  enter: function (node, parent, scope, state) {
+    if (!t.isExpressionStatement(node)) return;
+
+    var expr = node.expression;
+    if (!t.isAssignmentExpression(expr)) return;
+
+    if (!state.needsThis && expr.left === state.getThisId()) {
+      this.remove();
+    } else if (!state.needsArguments && expr.left === state.getArgumentsId() && t.isArrayExpression(expr.right)) {
+      return map(expr.right.elements, function (elem) {
+        return t.expressionStatement(elem);
+      });
+    }
+  }
+};
+
+exports.Function = function (node, parent, scope, file) {
+  var tailCall = new TailCallTransformer(node, scope, file);
+  tailCall.run();
+};
+
+},{"../../../messages":27,"../../../types":119,"../../../util":121,"lodash/array/flatten":192,"lodash/collection/map":201,"lodash/collection/reduceRight":202}],74:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+var buildBinaryExpression = function (left, right) {
+  return t.binaryExpression("+", left, right);
+};
+
+exports.check = function (node) {
+  return t.isTemplateLiteral(node) || t.isTaggedTemplateExpression(node);
+};
+
+exports.TaggedTemplateExpression = function (node, parent, scope, file) {
+  var args = [];
+  var quasi = node.quasi;
+
+  var strings = [];
+  var raw = [];
+
+  for (var i = 0; i < quasi.quasis.length; i++) {
+    var elem = quasi.quasis[i];
+    strings.push(t.literal(elem.value.cooked));
+    raw.push(t.literal(elem.value.raw));
+  }
+
+  strings = t.arrayExpression(strings);
+  raw = t.arrayExpression(raw);
+
+  var templateName = "tagged-template-literal";
+  if (file.isLoose("es6.templateLiterals")) templateName += "-loose";
+  args.push(t.callExpression(file.addHelper(templateName), [strings, raw]));
+
+  args = args.concat(quasi.expressions);
+
+  return t.callExpression(node.tag, args);
+};
+
+exports.TemplateLiteral = function (node) {
+  var nodes = [];
+  var i;
+
+  for (i = 0; i < node.quasis.length; i++) {
+    var elem = node.quasis[i];
+
+    nodes.push(t.literal(elem.value.cooked));
+
+    var expr = node.expressions.shift();
+    if (expr) nodes.push(expr);
+  }
+
+  if (nodes.length > 1) {
+    // remove redundant '' at the end of the expression
+    var last = nodes[nodes.length - 1];
+    if (t.isLiteral(last, { value: "" })) nodes.pop();
+
+    var root = buildBinaryExpression(nodes.shift(), nodes.shift());
+
+    for (i = 0; i < nodes.length; i++) {
+      root = buildBinaryExpression(root, nodes[i]);
+    }
+
+    return root;
+  } else {
+    return nodes[0];
+  }
+};
+
+},{"../../../types":119}],75:[function(require,module,exports){
+"use strict";
+
+var rewritePattern = require("regexpu/rewrite-pattern");
+var pull           = require("lodash/array/pull");
+var t              = require("../../../types");
+
+exports.check = function (node) {
+  return t.isLiteral(node) && node.regex && node.regex.flags.indexOf("u") >= 0;
+};
+
+exports.Literal = function (node) {
+  var regex = node.regex;
+  if (!regex) return;
+
+  var flags = regex.flags.split("");
+  if (regex.flags.indexOf("u") < 0) return;
+  pull(flags, "u");
+
+  regex.pattern = rewritePattern(regex.pattern, regex.flags);
+  regex.flags   = flags.join("");
+};
+
+},{"../../../types":119,"lodash/array/pull":194,"regexpu/rewrite-pattern":320}],76:[function(require,module,exports){
+"use strict";
+
+// https://github.com/zenparsing/es-abstract-refs
+
+var util = require("../../../util");
+var t    = require("../../../types");
+
+exports.experimental = true;
+
+var container = function (parent, call, ret, file) {
+  if (t.isExpressionStatement(parent) && !file.isConsequenceExpressionStatement(parent)) {
+    // we don't need to worry about return values
+    return call;
+  } else {
+    var exprs = [];
+    if (t.isSequenceExpression(call)) {
+      exprs = call.expressions;
+    } else {
+      exprs.push(call);
+    }
+    exprs.push(ret);
+    return t.sequenceExpression(exprs);
+  }
+};
+
+exports.AssignmentExpression = function (node, parent, scope, file) {
+  var left = node.left;
+  if (!t.isVirtualPropertyExpression(left)) return;
+
+  var value = node.right;
+  var temp;
+
+  // we need to return `node.right`
+  if (!t.isExpressionStatement(parent)) {
+    temp = scope.generateTempBasedOnNode(node.right);
+    if (temp) value = temp;
+  }
+
+  if (node.operator !== "=") {
+    value = t.binaryExpression(
+      node.operator[0],
+      util.template("abstract-expression-get", {
+        PROPERTY: node.property,
+        OBJECT:   node.object
+      }),
+      value
+    );
+  }
+
+  var call = util.template("abstract-expression-set", {
+    PROPERTY: left.property,
+    OBJECT:   left.object,
+    VALUE:    value
+  });
+
+  if (temp) {
+    call = t.sequenceExpression([
+      t.assignmentExpression("=", temp, node.right),
+      call
+    ]);
+  }
+
+  return container(parent, call, value, file);
+};
+
+exports.UnaryExpression = function (node, parent, scope, file) {
+  var arg = node.argument;
+  if (!t.isVirtualPropertyExpression(arg)) return;
+  if (node.operator !== "delete") return;
+
+  var call = util.template("abstract-expression-delete", {
+    PROPERTY: arg.property,
+    OBJECT:   arg.object
+  });
+
+  return container(parent, call, t.literal(true), file);
+};
+
+exports.CallExpression = function (node, parent, scope) {
+  var callee = node.callee;
+  if (!t.isVirtualPropertyExpression(callee)) return;
+
+  var temp = scope.generateTempBasedOnNode(callee.object);
+
+  var call = util.template("abstract-expression-call", {
+    PROPERTY: callee.property,
+    OBJECT:   temp || callee.object
+  });
+
+  call.arguments = call.arguments.concat(node.arguments);
+
+  if (temp) {
+    return t.sequenceExpression([
+      t.assignmentExpression("=", temp, callee.object),
+      call
+    ]);
+  } else {
+    return call;
+  }
+};
+
+exports.VirtualPropertyExpression = function (node) {
+  return util.template("abstract-expression-get", {
+    PROPERTY: node.property,
+    OBJECT:   node.object
+  });
+};
+
+exports.PrivateDeclaration = function (node) {
+  return t.variableDeclaration("const", node.declarations.map(function (id) {
+    return t.variableDeclarator(id, t.newExpression(t.identifier("WeakMap"), []));
+  }));
+};
+
+},{"../../../types":119,"../../../util":121}],77:[function(require,module,exports){
+"use strict";
+
+var buildComprehension = require("../../helpers/build-comprehension");
+var traverse           = require("../../../traversal");
+var util               = require("../../../util");
+var t                  = require("../../../types");
+
+exports.experimental = true;
+
+exports.ComprehensionExpression = function (node, parent, scope, file) {
+  var callback = array;
+  if (node.generator) callback = generator;
+  return callback(node, parent, scope, file);
+};
+
+var generator = function (node) {
+  var body = [];
+  var container = t.functionExpression(null, [], t.blockStatement(body), true);
+  container._aliasFunction = true;
+
+  body.push(buildComprehension(node, function () {
+    return t.expressionStatement(t.yieldExpression(node.body));
+  }));
+
+  return t.callExpression(container, []);
+};
+
+var array = function (node, parent, scope, file) {
+  var uid = scope.generateUidBasedOnNode(parent, file);
+
+  var container = util.template("array-comprehension-container", {
+    KEY: uid
+  });
+  container.callee._aliasFunction = true;
+
+  var block = container.callee.body;
+  var body  = block.body;
+
+  if (traverse.hasType(node, scope, "YieldExpression", t.FUNCTION_TYPES)) {
+    container.callee.generator = true;
+    container = t.yieldExpression(container, true);
+  }
+
+  var returnStatement = body.pop();
+
+  body.push(buildComprehension(node, function () {
+    return util.template("array-push", {
+      STATEMENT: node.body,
+      KEY:       uid
+    }, true);
+  }));
+  body.push(returnStatement);
+
+  return container;
+};
+
+},{"../../../traversal":114,"../../../types":119,"../../../util":121,"../../helpers/build-comprehension":31}],78:[function(require,module,exports){
+"use strict";
+
+// https://github.com/rwaldron/exponentiation-operator
+
+exports.experimental = true;
+
+var build = require("../../helpers/build-binary-assignment-operator-transformer");
+var t     = require("../../../types");
+
+var MATH_POW = t.memberExpression(t.identifier("Math"), t.identifier("pow"));
+
+build(exports, {
+  operator: "**",
+
+  build: function (left, right) {
+    return t.callExpression(MATH_POW, [left, right]);
+  }
+});
+
+},{"../../../types":119,"../../helpers/build-binary-assignment-operator-transformer":30}],79:[function(require,module,exports){
+"use strict";
+
+// https://github.com/sebmarkbage/ecmascript-rest-spread
+
+var t = require("../../../types");
+
+exports.experimental = true;
+
+exports.manipulateOptions = function (opts) {
+  if (opts.whitelist.length) opts.whitelist.push("es6.destructuring");
+};
+
+var hasSpread = function (node) {
+  for (var i = 0; i < node.properties.length; i++) {
+    if (t.isSpreadProperty(node.properties[i])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+exports.ObjectExpression = function (node, parent, scope, file) {
+  if (!hasSpread(node)) return;
+
+  var args = [];
+  var props = [];
+
+  var push = function () {
+    if (!props.length) return;
+    args.push(t.objectExpression(props));
+    props = [];
+  };
+
+  for (var i = 0; i < node.properties.length; i++) {
+    var prop = node.properties[i];
+    if (t.isSpreadProperty(prop)) {
+      push();
+      args.push(prop.argument);
+    } else {
+      props.push(prop);
+    }
+  }
+
+  push();
+
+  if (!t.isObjectExpression(args[0])) {
+    args.unshift(t.objectExpression([]));
+  }
+
+  return t.callExpression(file.addHelper("extends"), args);
+};
+
+},{"../../../types":119}],80:[function(require,module,exports){
+module.exports = {
+  useStrict:                               require("./other/use-strict"),
+
+  // this goes at the start so we only transform the original user code
+  "spec.functionName":                     require("./spec/function-name"),
+
+  "validation.undeclaredVariableCheck":    require("./validation/undeclared-variable-check"),
+  "validation.noForInOfAssignment":        require("./validation/no-for-in-of-assignment"),
+  "validation.setters":                    require("./validation/setters"),
+  "validation.react":                      require("./validation/react"),
+  "spec.blockScopedFunctions":             require("./spec/block-scoped-functions"),
+
+  // needs to be before `_aliasFunction`
+  "es6.arrowFunctions":                    require("./es6/arrow-functions"),
+
+  "playground.malletOperator":             require("./playground/mallet-operator"),
+  "playground.methodBinding":              require("./playground/method-binding"),
+  "playground.memoizationOperator":        require("./playground/memoization-operator"),
+  "playground.objectGetterMemoization":    require("./playground/object-getter-memoization"),
+
+  reactCompat:                             require("./other/react-compat"),
+  flow:                                    require("./other/flow"),
+  react:                                   require("./other/react"),
+
+  _modules:                                require("./internal/modules"),
+
+  // needs to be before `regenerator` due to generator comprehensions
+  // needs to be before `_aliasFunction`
+  "es7.comprehensions":                    require("./es7/comprehensions"),
+
+  "es6.classes":                           require("./es6/classes"),
+
+  asyncToGenerator:                        require("./other/async-to-generator"),
+  bluebirdCoroutines:                      require("./other/bluebird-coroutines"),
+
+  "es6.objectSuper":                       require("./es6/object-super"),
+  "es7.objectRestSpread":                  require("./es7/object-rest-spread"),
+  "es7.exponentiationOperator":            require("./es7/exponentiation-operator"),
+  "es6.templateLiterals":                  require("./es6/template-literals"),
+
+  "es5.properties.mutators":               require("./es5/properties.mutators"),
+  "es6.properties.shorthand":              require("./es6/properties.shorthand"),
+
+  // needs to be before `_aliasFunction` due to define property closure
+  "es6.properties.computed":               require("./es6/properties.computed"),
+
+  "es6.forOf":                             require("./es6/for-of"),
+
+  "es6.unicodeRegex":                      require("./es6/unicode-regex"),
+  "es7.abstractReferences":                require("./es7/abstract-references"),
+
+  "es6.constants":                         require("./es6/constants"),
+
+  // needs to be before `es6.parameters.default` as default parameters will destroy the rest param
+  "es6.parameters.rest":                   require("./es6/parameters.rest"),
+
+  // needs to be after `es6.parameters.rest` as we use `toArray` and avoid turning an already known array into one
+  "es6.spread":                            require("./es6/spread"),
+
+  // needs to be before `es6.blockScoping` as default parameters have a TDZ
+  "es6.parameters.default":                require("./es6/parameters.default"),
+
+  // needs to be before `es6.blockScoping` as let variables may be produced
+  "es6.destructuring":                     require("./es6/destructuring"),
+
+  // needs to be before `_aliasFunction` due to block scopes sometimes being wrapped in a
+  // closure
+  "es6.blockScoping":                      require("./es6/block-scoping"),
+
+  // needs to be after `es6.blockScoping` due to needing `letReferences` set on blocks
+  "es6.blockScopingTDZ":                   require("./es6/block-scoping-tdz"),
+
+  // needs to be after `es6.parameters.*` and `es6.blockScoping` due to needing pure
+  // identifiers in parameters and variable declarators
+  "es6.tailCall":                          require("./es6/tail-call"),
+
+  regenerator:                             require("./other/regenerator"),
+
+  // needs to be after `regenerator` due to needing `regeneratorRuntime` references
+  // needs to be after `es6.forOf` due to needing `Symbol.iterator` references
+  // needs to be before `es6.modules` due to dynamic imports
+  runtime:                                require("./other/runtime"),
+
+  // needs to be before `_blockHoist` due to function hoisting etc
+  "es6.modules":                           require("./es6/modules"),
+
+  _blockHoist:                             require("./internal/block-hoist"),
+
+  "spec.protoToAssign":                    require("./spec/proto-to-assign"),
+
+  _declarations:                           require("./internal/declarations"),
+
+  _aliasFunctions:                         require("./internal/alias-functions"),
+
+  "spec.typeofSymbol":                     require("./spec/typeof-symbol"),
+  "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
+
+  _useStrict:                              require("./internal/use-strict"),
+  _moduleFormatter:                        require("./internal/module-formatter"),
+
+  "es3.propertyLiterals":                  require("./es3/property-literals"),
+  "es3.memberExpressionLiterals":          require("./es3/member-expression-literals"),
+
+  "minification.removeDebugger":           require("./minification/remove-debugger"),
+  "minification.removeConsoleCalls":       require("./minification/remove-console-calls"),
+  "minification.deadCodeElimination":      require("./minification/dead-code-elimination"),
+  "minification.renameLocalVariables":     require("./minification/rename-local-variables"),
+
+  _cleanUp:                                require("./internal/cleanup")
+};
+
+},{"./es3/member-expression-literals":56,"./es3/property-literals":57,"./es5/properties.mutators":58,"./es6/arrow-functions":59,"./es6/block-scoping":61,"./es6/block-scoping-tdz":60,"./es6/classes":62,"./es6/constants":63,"./es6/destructuring":64,"./es6/for-of":65,"./es6/modules":66,"./es6/object-super":67,"./es6/parameters.default":68,"./es6/parameters.rest":69,"./es6/properties.computed":70,"./es6/properties.shorthand":71,"./es6/spread":72,"./es6/tail-call":73,"./es6/template-literals":74,"./es6/unicode-regex":75,"./es7/abstract-references":76,"./es7/comprehensions":77,"./es7/exponentiation-operator":78,"./es7/object-rest-spread":79,"./internal/alias-functions":81,"./internal/block-hoist":82,"./internal/cleanup":83,"./internal/declarations":84,"./internal/module-formatter":85,"./internal/modules":86,"./internal/use-strict":87,"./minification/dead-code-elimination":88,"./minification/remove-console-calls":89,"./minification/remove-debugger":90,"./minification/rename-local-variables":91,"./other/async-to-generator":92,"./other/bluebird-coroutines":93,"./other/flow":94,"./other/react":96,"./other/react-compat":95,"./other/regenerator":97,"./other/runtime":98,"./other/use-strict":99,"./playground/mallet-operator":100,"./playground/memoization-operator":101,"./playground/method-binding":102,"./playground/object-getter-memoization":103,"./spec/block-scoped-functions":104,"./spec/function-name":105,"./spec/proto-to-assign":106,"./spec/typeof-symbol":107,"./spec/undefined-to-void":108,"./validation/no-for-in-of-assignment":109,"./validation/react":110,"./validation/setters":111,"./validation/undeclared-variable-check":112}],81:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+var functionChildrenVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isFunction(node) && !node._aliasFunction) {
+      return this.skip();
+    }
+
+    if (node._ignoreAliasFunctions) return this.skip();
+
+    var getId;
+
+    if (t.isIdentifier(node) && node.name === "arguments") {
+      getId = state.getArgumentsId;
+    } else if (t.isThisExpression(node)) {
+      getId = state.getThisId;
+    } else {
+      return;
+    }
+
+    if (t.isReferenced(node, parent)) return getId();
+  }
+};
+
+var functionVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (!node._aliasFunction) {
+      if (t.isFunction(node)) {
+        // stop traversal of this node as it'll be hit again by this transformer
+        return this.skip();
+      } else {
+        return;
+      }
+    }
+
+    // traverse all child nodes of this function and find `arguments` and `this`
+    scope.traverse(node, functionChildrenVisitor, state);
+
+    return this.skip();
+  }
+};
+
+var go = function (getBody, node, scope) {
+  var argumentsId;
+  var thisId;
+
+  var state = {
+    getArgumentsId: function () {
+      return argumentsId = argumentsId || scope.generateUidIdentifier("arguments");
+    },
+    getThisId: function () {
+      return thisId = thisId || scope.generateUidIdentifier("this");
+    }
+  };
+
+  // traverse the function and find all alias functions so we can alias
+  // `arguments` and `this` if necessary
+  scope.traverse(node, functionVisitor, state);
+
+  var body;
+
+  var pushDeclaration = function (id, init) {
+    body = body || getBody();
+    body.unshift(t.variableDeclaration("var", [
+      t.variableDeclarator(id, init)
+    ]));
+  };
+
+  if (argumentsId) {
+    pushDeclaration(argumentsId, t.identifier("arguments"));
+  }
+
+  if (thisId) {
+    pushDeclaration(thisId, t.thisExpression());
+  }
+};
+
+exports.Program = function (node, parent, scope) {
+  go(function () {
+    return node.body;
+  }, node, scope);
+};
+
+exports.FunctionDeclaration =
+exports.FunctionExpression = function (node, parent, scope) {
+  go(function () {
+    t.ensureBlock(node);
+    return node.body.body;
+  }, node, scope);
+};
+
+},{"../../../types":119}],82:[function(require,module,exports){
+"use strict";
+
+var groupBy = require("lodash/collection/groupBy");
+var flatten = require("lodash/array/flatten");
+var values  = require("lodash/object/values");
+
+// Priority:
+//
+//  - 0 We want this to be at the **very** bottom
+//  - 1 Default node position
+//  - 2 Priority over normal nodes
+//  - 3 We want this to be at the **very** top
+
+exports.BlockStatement =
+exports.Program = {
+  exit: function (node) {
+    var hasChange = false;
+    for (var i = 0; i < node.body.length; i++) {
+      var bodyNode = node.body[i];
+      if (bodyNode && bodyNode._blockHoist != null) hasChange = true;
+    }
+    if (!hasChange) return;
+
+    var nodePriorities = groupBy(node.body, function (bodyNode) {
+      var priority = bodyNode._blockHoist;
+      if (priority == null) priority = 1;
+      if (priority === true) priority = 2;
+      return priority;
+    });
+
+    node.body = flatten(values(nodePriorities).reverse());
+  }
+};
+
+},{"lodash/array/flatten":192,"lodash/collection/groupBy":199,"lodash/object/values":299}],83:[function(require,module,exports){
+exports.SequenceExpression = function (node) {
+  if (node.expressions.length === 1) {
+    return node.expressions[0];
+  }
+};
+
+},{}],84:[function(require,module,exports){
+"use strict";
+
+var useStrict = require("../../helpers/use-strict");
+var t         = require("../../../types");
+
+exports.secondPass = true;
+
+exports.BlockStatement =
+exports.Program = function (node, parent, scope, file) {
+  if (!node._declarations) return;
+
+  useStrict.wrap(node, function () {
+    var kinds = {};
+    var kind;
+
+    for (var i in node._declarations) {
+      var declar = node._declarations[i];
+
+      kind = declar.kind || "var";
+      var declarNode = t.variableDeclarator(declar.id, declar.init);
+
+      if (declar.init) {
+        node.body.unshift(file.attachAuxiliaryComment(t.variableDeclaration(kind, [declarNode])));
+      } else {
+        kinds[kind] = kinds[kind] || [];
+        kinds[kind].push(declarNode);
+      }
+    }
+
+    for (kind in kinds) {
+      node.body.unshift(file.attachAuxiliaryComment(t.variableDeclaration(kind, kinds[kind])));
+    }
+
+    node._declarations = null;
+  });
+};
+
+},{"../../../types":119,"../../helpers/use-strict":40}],85:[function(require,module,exports){
+"use strict";
+
+var useStrict = require("../../helpers/use-strict");
+
+exports.Program = function (program, parent, scope, file) {
+  if (!file.transformers["es6.modules"].canRun()) return;
+
+  useStrict.wrap(program, function () {
+    program.body = file.dynamicImports.concat(program.body);
+  });
+
+  if (file.moduleFormatter.transform) {
+    file.moduleFormatter.transform(program);
+  }
+};
+
+},{"../../helpers/use-strict":40}],86:[function(require,module,exports){
+"use strict";
+
+// in this transformer we have to split up classes and function declarations
+// from their exports. why? because sometimes we need to replace classes with
+// nodes that aren't allowed in the same contexts. also, if you're exporting
+// a generator function as a default then regenerator will destroy the export
+// declaration and leave a variable declaration in it's place... yeah, handy.
+
+var t = require("../../../types");
+
+var resolveModuleSource = function (node, parent, scope, file) {
+  var resolveModuleSource = file.opts.resolveModuleSource;
+  if (node.source && resolveModuleSource) {
+    node.source.value = resolveModuleSource(node.source.value);
+  }
+};
+
+exports.check = function (node) {
+  return t.isImportDeclaration(node) || t.isExportDeclaration(node);
+};
+
+exports.ImportDeclaration = resolveModuleSource;
+
+exports.ExportDeclaration = function (node, parent, scope) {
+  resolveModuleSource.apply(null, arguments);
+
+  // flow type
+  if (node.isType) return;
+
+  var declar = node.declaration;
+
+  if (node.default) {
+    if (t.isClassDeclaration(declar)) {
+      node.declaration = declar.id;
+      return [declar, node];
+    } else if (t.isClassExpression(declar)) {
+      var temp = scope.generateUidIdentifier("default");
+      declar = t.variableDeclaration("var", [
+        t.variableDeclarator(temp, declar)
+      ]);
+      node.declaration = temp;
+      return [declar, node];
+    } else if (t.isFunctionDeclaration(declar)) {
+      node._blockHoist = 2;
+      node.declaration = declar.id;
+      return [declar, node];
+    }
+  } else {
+    if (t.isFunctionDeclaration(declar)) {
+      node.specifiers  = [t.importSpecifier(declar.id, declar.id)];
+      node.declaration = null;
+      node._blockHoist = 2;
+      return [declar, node];
+    }
+  }
+};
+
+},{"../../../types":119}],87:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.Program = function (program, parent, scope, file) {
+  if (file.transformers.useStrict.canRun()) {
+    program.body.unshift(t.expressionStatement(t.literal("use strict")));
+  }
+};
+
+},{"../../../types":119}],88:[function(require,module,exports){
+var t = require("../../../types");
+
+exports.optional = true;
+
+exports.ExpressionStatement = function (node) {
+  // remove consequence-less expressions such as local variables and literals
+  // note: will remove directives
+  //
+  //   var foo = true; foo; -> var foo = true;
+  //   "foo"; ->
+  //
+
+  var expr = node.expression;
+  if (t.isLiteral(expr) || (t.isIdentifier(node) && t.hasBinding(node.name))) {
+    this.remove();
+  }
+};
+
+exports.IfStatement = {
+  exit: function (node) {
+    // todo: in scenarios where we can just return the consequent or
+    // alternate we should drop the block statement if it contains no
+    // block scoped variables
+
+    var consequent = node.consequent;
+    var alternate  = node.alternate;
+    var test       = node.test;
+
+    // we can check if a test will be truthy 100% and if so then we can inline
+    // the consequent and completely ignore the alternate
+    //
+    //   if (true) { foo; } -> { foo; }
+    //   if ("foo") { foo; } -> { foo; }
+    //
+
+    if (t.isLiteral(test) && test.value) {
+      return consequent;
+    }
+
+    // we can check if a test will be falsy 100% and if so we can inline the
+    // alternate if there is one and completely remove the consequent
+    //
+    //   if ("") { bar; } else { foo; } -> { foo; }
+    //   if ("") { bar; } ->
+    //
+
+    if (t.isFalsyExpression(test)) {
+      if (alternate) {
+        return alternate;
+      } else {
+        return this.remove();
+      }
+    }
+
+    // remove alternate blocks that are empty
+    //
+    //   if (foo) { foo; } else {} -> if (foo) { foo; }
+    //
+
+    if (t.isBlockStatement(alternate) && !alternate.body.length) {
+      alternate = node.alternate = null;
+    }
+
+    // if the consequent block is empty turn alternate blocks into a consequent
+    // and flip the test
+    //
+    //   if (foo) {} else { bar; } -> if (!foo) { bar; }
+    //
+
+    if (t.blockStatement(consequent) && !consequent.body.length && t.isBlockStatement(alternate) && alternate.body.length) {
+      node.consequent = node.alternate;
+      node.alternate  = null;
+      node.test       = t.unaryExpression("!", test, true);
+    }
+  }
+};
+
+},{"../../../types":119}],89:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+var isConsole = t.buildMatchMemberExpression("console", true);
+
+exports.optional = true;
+
+exports.CallExpression = function (node, parent) {
+  if (isConsole(node.callee)) {
+    if (t.isExpressionStatement(parent)) {
+      this.parentPath.remove();
+    } else {
+      this.remove();
+    }
+  }
+};
+
+},{"../../../types":119}],90:[function(require,module,exports){
+var t = require("../../../types");
+
+exports.optional = true;
+
+exports.ExpressionStatement = function (node) {
+  if (t.isIdentifier(node.expression, { name: "debugger" })) {
+    this.remove();
+  }
+};
+
+},{"../../../types":119}],91:[function(require,module,exports){
+//var t = require("../../../types");
+
+exports.optional = true;
+
+exports.Scopable = function () {
+  //for (var name in scope.bindings) {
+  //  scope.rename(name, scope.generateUidIdentifier("a").name);
+  //}
+};
+
+},{}],92:[function(require,module,exports){
+"use strict";
+
+var remapAsyncToGenerator = require("../../helpers/remap-async-to-generator");
+var bluebirdCoroutines    = require("./bluebird-coroutines");
+
+exports.optional = true;
+
+exports.manipulateOptions = bluebirdCoroutines.manipulateOptions;
+
+exports.Function = function (node, parent, scope, file) {
+  if (!node.async || node.generator) return;
+
+  return remapAsyncToGenerator(node, file.addHelper("async-to-generator"), scope);
+};
+
+},{"../../helpers/remap-async-to-generator":38,"./bluebird-coroutines":93}],93:[function(require,module,exports){
+"use strict";
+
+var remapAsyncToGenerator = require("../../helpers/remap-async-to-generator");
+var t                     = require("../../../types");
+
+exports.manipulateOptions = function (opts) {
+  opts.experimental = true;
+  opts.blacklist.push("regenerator");
+};
+
+exports.optional = true;
+
+exports.Function = function (node, parent, scope, file) {
+  if (!node.async || node.generator) return;
+
+  return remapAsyncToGenerator(
+    node,
+    t.memberExpression(file.addImport("bluebird", null, true), t.identifier("coroutine")),
+    scope
+  );
+};
+
+},{"../../../types":119,"../../helpers/remap-async-to-generator":38}],94:[function(require,module,exports){
+var t = require("../../../types");
+
+exports.TypeCastExpression = function (node) {
+  return node.expression;
+};
+
+exports.ImportDeclaration = function (node) {
+  if (node.isType) this.remove();
+};
+
+exports.ExportDeclaration = function (node) {
+  if (t.isTypeAlias(node.declaration)) this.remove();
+};
+
+},{"../../../types":119}],95:[function(require,module,exports){
+"use strict";
+
+var react = require("../../helpers/react");
+var t     = require("../../../types");
+
+exports.manipulateOptions = function (opts) {
+  opts.blacklist.push("react");
+};
+
+exports.optional = true;
+
+require("../../helpers/build-react-transformer")(exports, {
+  pre: function (state) {
+    state.callee = state.tagExpr;
+  },
+
+  post: function (state) {
+    if (react.isCompatTag(state.tagName)) {
+      state.call = t.callExpression(
+        t.memberExpression(
+          t.memberExpression(t.identifier("React"), t.identifier("DOM")),
+          state.tagExpr,
+          t.isLiteral(state.tagExpr)
+        ),
+        state.args
+      );
+    }
+  }
+});
+
+},{"../../../types":119,"../../helpers/build-react-transformer":33,"../../helpers/react":37}],96:[function(require,module,exports){
+"use strict";
+
+var react = require("../../helpers/react");
+var t     = require("../../../types");
+
+var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
+
+exports.Program = function (node, parent, scope, file) {
+  var id = "React.createElement";
+
+  for (var i = 0; i < file.ast.comments.length; i++) {
+    var comment = file.ast.comments[i];
+    var matches = JSX_ANNOTATION_REGEX.exec(comment.value);
+    if (matches) {
+      id = matches[1];
+      if (id === "React.DOM") {
+        throw file.errorWithNode(comment, "The @jsx React.DOM pragma has been deprecated as of React 0.12");
+      } else {
+        break;
+      }
+    }
+  }
+
+  file.set("jsxIdentifier", id.split(".").map(t.identifier).reduce(function (object, property) {
+    return t.memberExpression(object, property);
+  }));
+};
+
+require("../../helpers/build-react-transformer")(exports, {
+  pre: function (state) {
+    var tagName = state.tagName;
+    var args    = state.args;
+    if (react.isCompatTag(tagName)) {
+      args.push(t.literal(tagName));
+    } else {
+      args.push(state.tagExpr);
+    }
+  },
+
+  post: function (state, file) {
+    state.callee = file.get("jsxIdentifier");
+  }
+});
+
+},{"../../../types":119,"../../helpers/build-react-transformer":33,"../../helpers/react":37}],97:[function(require,module,exports){
+"use strict";
+
+var regenerator = require("regenerator-babel");
+var t           = require("../../../types");
+
+exports.check = function (node) {
+  return t.isFunction(node) && (node.async || node.generator);
+};
+
+exports.Program = {
+  enter: function (ast) {
+    regenerator.transform(ast);
+    this.stop();
+  }
+};
+
+},{"../../../types":119,"regenerator-babel":312}],98:[function(require,module,exports){
+"use strict";
+
+var includes = require("lodash/collection/includes");
+var util     = require("../../../util");
+var core     = require("core-js/library");
+var has      = require("lodash/object/has");
+var t        = require("../../../types");
+
+var isSymboliterator = t.buildMatchMemberExpression("Symbol.iterator");
+
+var coreHas = function (node) {
+  return node.name !== "_" && has(core, node.name);
+};
+
+var ALIASABLE_CONSTRUCTORS = [
+  "Symbol",
+  "Promise",
+  "Map",
+  "WeakMap",
+  "Set",
+  "WeakSet"
+];
+
+var astVisitor = {
+  enter: function (node, parent, scope, file) {
+    var prop;
+
+    if (t.isMemberExpression(node) && t.isReferenced(node, parent)) {
+      // Array.from -> _core.Array.from
+      var obj = node.object;
+      prop = node.property;
+
+      if (!t.isReferenced(obj, node)) return;
+
+      if (!node.computed && coreHas(obj) && has(core[obj.name], prop.name) && !scope.getBindingIdentifier(obj.name)) {
+        this.skip();
+        return t.prependToMemberExpression(node, file.get("coreIdentifier"));
+      }
+    } else if (t.isReferencedIdentifier(node, parent) && !t.isMemberExpression(parent) && includes(ALIASABLE_CONSTRUCTORS, node.name) && !scope.getBindingIdentifier(node.name)) {
+      // Symbol() -> _core.Symbol(); new Promise -> new _core.Promise
+      return t.memberExpression(file.get("coreIdentifier"), node);
+    } else if (t.isCallExpression(node)) {
+      // arr[Symbol.iterator]() -> _core.$for.getIterator(arr)
+
+      var callee = node.callee;
+      if (node.arguments.length) return false;
+
+      if (!t.isMemberExpression(callee)) return false;
+      if (!callee.computed) return false;
+
+      prop = callee.property;
+      if (!isSymboliterator(prop)) return false;
+
+      return util.template("corejs-iterator", {
+        CORE_ID: file.get("coreIdentifier"),
+        VALUE:   callee.object
+      });
+    } else if (t.isBinaryExpression(node)) {
+      // Symbol.iterator in arr -> core.$for.isIterable(arr)
+
+      if (node.operator !== "in") return;
+
+      var left = node.left;
+      if (!isSymboliterator(left)) return;
+
+      return util.template("corejs-is-iterator", {
+        CORE_ID: file.get("coreIdentifier"),
+        VALUE:   node.right
+      });
+    }
+  }
+};
+
+exports.optional = true;
+
+exports.manipulateOptions = function (opts) {
+  if (opts.whitelist.length) opts.whitelist.push("es6.modules");
+};
+
+exports.Program = function (node, parent, scope, file) {
+  scope.traverse(node, astVisitor, file);
+};
+
+exports.pre = function (file) {
+  file.setDynamic("helpersNamespace", function () {
+    return file.addImport("babel-runtime/helpers", "babelHelpers");
+  });
+
+  file.setDynamic("coreIdentifier", function () {
+    return file.addImport("babel-runtime/core-js", "core");
+  });
+
+  file.setDynamic("regeneratorIdentifier", function () {
+    return file.addImport("babel-runtime/regenerator", "regeneratorRuntime");
+  });
+};
+
+exports.Identifier = function (node, parent, scope, file) {
+  if (t.isReferencedIdentifier(node, parent, { name: "regeneratorRuntime" })) {
+    return file.get("regeneratorIdentifier");
+  }
+};
+
+},{"../../../types":119,"../../../util":121,"core-js/library":172,"lodash/collection/includes":200,"lodash/object/has":296}],99:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+var t        = require("../../../types");
+
+exports.Program = function (program) {
+  var first = program.body[0];
+  if (t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" })) {
+    program.body.shift();
+  }
+};
+
+exports.FunctionDeclaration =
+exports.FunctionExpression = function () {
+  this.skip();
+};
+
+exports.ThisExpression = function () {
+  return t.identifier("undefined");
+};
+
+exports.CallExpression = function (node, parent, scope, file) {
+  if (t.isIdentifier(node.callee, { name: "eval" })) {
+    throw file.errorWithNode(node, messages.get("evalInStrictMode"));
+  }
+};
+
+},{"../../../messages":27,"../../../types":119}],100:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+var build    = require("../../helpers/build-conditional-assignment-operator-transformer");
+var t        = require("../../../types");
+
+exports.playground = true;
+
+build(exports, {
+  is: function (node, file) {
+    var is = t.isAssignmentExpression(node) && node.operator === "||=";
+    if (is) {
+      var left = node.left;
+      if (!t.isMemberExpression(left) && !t.isIdentifier(left)) {
+        throw file.errorWithNode(left, messages.get("expectedMemberExpressionOrIdentifier"));
+      }
+      return true;
+    }
+  },
+
+  build: function (node) {
+    return t.unaryExpression("!", node, true);
+  }
+});
+
+},{"../../../messages":27,"../../../types":119,"../../helpers/build-conditional-assignment-operator-transformer":32}],101:[function(require,module,exports){
+"use strict";
+
+var build = require("../../helpers/build-conditional-assignment-operator-transformer");
+var t     = require("../../../types");
+
+exports.playground = true;
+
+build(exports, {
+  is: function (node) {
+    var is = t.isAssignmentExpression(node) && node.operator === "?=";
+    if (is) t.assertMemberExpression(node.left);
+    return is;
+  },
+
+  build: function (node, file) {
+    return t.unaryExpression(
+      "!",
+      t.callExpression(
+        t.memberExpression(file.addHelper("has-own"), t.identifier("call")),
+        [node.object, node.property]
+      ),
+      true
+    );
+  }
+});
+
+},{"../../../types":119,"../../helpers/build-conditional-assignment-operator-transformer":32}],102:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.playground = true;
+
+exports.BindMemberExpression = function (node, parent, scope) {
+  var object = node.object;
+  var prop   = node.property;
+
+  var temp = scope.generateTempBasedOnNode(node.object);
+  if (temp) object = temp;
+
+  var call = t.callExpression(
+    t.memberExpression(t.memberExpression(object, prop), t.identifier("bind")),
+    [object].concat(node.arguments)
+  );
+
+  if (temp) {
+    return t.sequenceExpression([
+      t.assignmentExpression("=", temp, node.object),
+      call
+    ]);
+  } else {
+    return call;
+  }
+};
+
+exports.BindFunctionExpression = function (node, parent, scope) {
+  var buildCall = function (args) {
+    var param = scope.generateUidIdentifier("val");
+    return t.functionExpression(null, [param], t.blockStatement([
+      t.returnStatement(t.callExpression(t.memberExpression(param, node.callee), args))
+    ]));
+  };
+
+  var temp = scope.generateTemp("args");
+
+  return t.sequenceExpression([
+    t.assignmentExpression("=", temp, t.arrayExpression(node.arguments)),
+    buildCall(node.arguments.map(function (node, i) {
+      return t.memberExpression(temp, t.literal(i), true);
+    }))
+  ]);
+};
+
+},{"../../../types":119}],103:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.playground = true;
+
+var visitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isFunction(node)) return this.skip();
+
+    if (t.isReturnStatement(node) && node.argument) {
+      node.argument = t.memberExpression(t.callExpression(state.file.addHelper("define-property"), [
+        t.thisExpression(),
+        state.key,
+        node.argument
+      ]), state.key, true);
+    }
+  }
+};
+
+exports.Property =
+exports.MethodDefinition = function (node, parent, scope, file) {
+  if (node.kind !== "memo") return;
+  node.kind = "get";
+
+  var value = node.value;
+  t.ensureBlock(value);
+
+  var key = node.key;
+
+  if (t.isIdentifier(key) && !node.computed) {
+    key = t.literal(key.name);
+  }
+
+  var state = {
+    key:  key,
+    file: file
+  };
+
+  scope.traverse(value, visitor, state);
+
+  return node;
+};
+
+},{"../../../types":119}],104:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.BlockStatement = function (node, parent, scope, file) {
+  if ((t.isFunction(parent) && parent.body === node) || t.isExportDeclaration(parent)) {
+    return;
+  }
+
+  for (var i = 0; i < node.body.length; i++) {
+    var func = node.body[i];
+    if (!t.isFunctionDeclaration(func)) continue;
+
+    var declar = t.variableDeclaration("let", [
+      t.variableDeclarator(func.id, t.toExpression(func))
+    ]);
+
+    // hoist it up above everything else
+    declar._blockHoist = 2;
+
+    // todo: name this
+    func.id = null;
+
+    node.body[i] = declar;
+
+    file.checkNode(declar);
+  }
+};
+
+},{"../../../types":119}],105:[function(require,module,exports){
+"use strict";
+
+var nameMethod = require("../../helpers/name-method");
+
+exports.FunctionExpression = nameMethod.bare;
+
+},{"../../helpers/name-method":36}],106:[function(require,module,exports){
+"use strict";
+
+var t    = require("../../../types");
+var pull = require("lodash/array/pull");
+
+var isProtoKey = function (node) {
+  return t.isLiteral(t.toComputedKey(node, node.key), { value: "__proto__" });
+};
+
+var isProtoAssignmentExpression = function (node) {
+  var left = node.left;
+  return t.isMemberExpression(left) && t.isLiteral(t.toComputedKey(left, left.property), { value: "__proto__" });
+};
+
+var buildDefaultsCallExpression = function (expr, ref, file) {
+  return t.expressionStatement(t.callExpression(file.addHelper("defaults"), [ref, expr.right]));
+};
+
+exports.optional = true;
+exports.secondPass = true;
+
+exports.AssignmentExpression = function (node, parent, scope, file) {
+  if (!isProtoAssignmentExpression(node)) return;
+
+  var nodes = [];
+  var left  = node.left.object;
+  var temp  = scope.generateTempBasedOnNode(node.left.object);
+
+  nodes.push(t.expressionStatement(t.assignmentExpression("=", temp, left)));
+  nodes.push(buildDefaultsCallExpression(node, temp, file));
+  if (temp) nodes.push(temp);
+
+  return t.toSequenceExpression(nodes);
+};
+
+exports.ExpressionStatement = function (node, parent, scope, file) {
+  var expr = node.expression;
+  if (!t.isAssignmentExpression(expr, { operator: "=" })) return;
+
+  if (isProtoAssignmentExpression(expr)) {
+    return buildDefaultsCallExpression(expr, expr.left.object, file);
+  }
+};
+
+exports.ObjectExpression = function (node, parent, scope, file) {
+  var proto;
+
+  for (var i = 0; i < node.properties.length; i++) {
+    var prop = node.properties[i];
+
+    if (isProtoKey(prop)) {
+      proto = prop.value;
+      pull(node.properties, prop);
+    }
+  }
+
+  if (proto) {
+    var args = [t.objectExpression([]), proto];
+    if (node.properties.length) args.push(node);
+    return t.callExpression(file.addHelper("extends"), args);
+  }
+};
+
+},{"../../../types":119,"lodash/array/pull":194}],107:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.optional = true;
+
+exports.UnaryExpression = function (node, parent, scope, file) {
+  this.skip();
+
+  if (node.operator === "typeof") {
+    var call = t.callExpression(file.addHelper("typeof"), [node.argument]);
+    if (t.isIdentifier(node.argument)) {
+      var undefLiteral = t.literal("undefined");
+      return t.conditionalExpression(
+        t.binaryExpression("===", t.unaryExpression("typeof", node.argument), undefLiteral),
+        undefLiteral,
+        call
+      );
+    } else {
+      return call;
+    }
+  }
+};
+
+},{"../../../types":119}],108:[function(require,module,exports){
+"use strict";
+
+var t = require("../../../types");
+
+exports.optional = true;
+
+exports.Identifier = function (node, parent) {
+  if (node.name === "undefined" && t.isReferenced(node, parent)) {
+    return t.unaryExpression("void", t.literal(0), true);
+  }
+};
+
+},{"../../../types":119}],109:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+var t        = require("../../../types");
+
+exports.check = t.isFor;
+
+exports.ForInStatement =
+exports.ForOfStatement = function (node, parent, scope, file) {
+  var left = node.left;
+  if (t.isVariableDeclaration(left)) {
+    var declar = left.declarations[0];
+    if (declar.init) throw file.errorWithNode(declar, messages.get("noAssignmentsInForHead"));
+  }
+};
+
+},{"../../../messages":27,"../../../types":119}],110:[function(require,module,exports){
+var messages = require("../../../messages");
+var t        = require("../../../types");
+
+// check if the input Literal `source` is an alternate casing of "react"
+var check = function (source, file) {
+  if (t.isLiteral(source)) {
+    var name  = source.value;
+    var lower = name.toLowerCase();
+
+    if (lower === "react" && name !== lower) {
+      throw file.errorWithNode(source, messages.get("didYouMean", "react"));
+    }
+  }
+};
+
+exports.CallExpression = function (node, parent, scope, file) {
+  if (t.isIdentifier(node.callee, { name: "require" }) && node.arguments.length === 1) {
+    check(node.arguments[0], file);
+  }
+};
+
+exports.ImportDeclaration =
+exports.ExportDeclaration = function (node, parent, scope, file) {
+  check(node.source, file);
+};
+
+},{"../../../messages":27,"../../../types":119}],111:[function(require,module,exports){
+"use strict";
+
+var messages = require("../../../messages");
+
+exports.check = function (node) {
+  return node.kind === "set";
+};
+
+exports.MethodDefinition =
+exports.Property = function (node, parent, scope, file) {
+  if (node.kind === "set" && node.value.params.length !== 1) {
+    throw file.errorWithNode(node.value, messages.get("settersInvalidParamLength"));
+  }
+};
+
+},{"../../../messages":27}],112:[function(require,module,exports){
+"use strict";
+
+var levenshtein = require("leven");
+var messages    = require("../../../messages");
+var t           = require("../../../types");
+
+exports.optional = true;
+
+exports.Identifier = function (node, parent, scope, file) {
+  if (!t.isReferenced(node, parent)) return;
+  if (scope.hasBinding(node.name)) return;
+
+  // get the closest declaration to offer as a suggestion
+  // the variable name may have just been mistyped
+
+  var bindings = scope.getAllBindings();
+
+  var closest;
+  var shortest = -1;
+
+  for (var name in bindings) {
+    var distance = levenshtein(node.name, name);
+    if (distance <= 0 || distance > 3) continue;
+    if (distance <= shortest) continue;
+
+    closest = name;
+    shortest = distance;
+  }
+
+  var msg;
+  if (closest) {
+    msg = messages.get("undeclaredVariableSuggestion", node.name, closest);
+  } else {
+    msg = messages.get("undeclaredVariable", node.name);
+  }
+
+  //
+
+  throw file.errorWithNode(node, msg, ReferenceError);
+};
+
+},{"../../../messages":27,"../../../types":119,"leven":188}],113:[function(require,module,exports){
+"use strict";
+
+module.exports = TraversalContext;
+
+var TraversalPath = require("./path");
+var flatten       = require("lodash/array/flatten");
+var compact       = require("lodash/array/compact");
+
+function TraversalContext(scope, opts, state, parentPath) {
+  this.shouldFlatten = false;
+  this.parentPath    = parentPath;
+
+  this.scope = scope;
+  this.state = state;
+  this.opts  = opts;
+}
+
+TraversalContext.prototype.flatten = function () {
+  this.shouldFlatten = true;
+};
+
+TraversalContext.prototype.visitNode = function (node, obj, key) {
+  var iteration = new TraversalPath(this, node, obj, key);
+  return iteration.visit();
+};
+
+TraversalContext.prototype.visit = function (node, key) {
+  var nodes = node[key];
+  if (!nodes) return;
+
+  if (!Array.isArray(nodes)) {
+    return this.visitNode(node, node, key);
+  }
+
+  // nothing to traverse!
+  if (nodes.length === 0) {
+    return;
+  }
+
+  for (var i = 0; i < nodes.length; i++) {
+    if (nodes[i] && this.visitNode(node, nodes, i)) {
+      return true;
+    }
+  }
+
+  if (this.shouldFlatten) {
+    node[key] = flatten(node[key]);
+
+    if (key === "body") {
+      // we can safely compact this
+      node[key] = compact(node[key]);
+    }
+  }
+};
+
+},{"./path":115,"lodash/array/compact":191,"lodash/array/flatten":192}],114:[function(require,module,exports){
+"use strict";
+
+module.exports = traverse;
+
+var TraversalContext = require("./context");
+var includes         = require("lodash/collection/includes");
+var t                = require("../types");
+
+function traverse(parent, opts, scope, state) {
+  if (!parent) return;
+
+  if (!opts.noScope && !scope) {
+    if (parent.type !== "Program" && parent.type !== "File") {
+      throw new Error("Must pass a scope unless traversing a Program/File got a " + parent.type + " node");
+    }
+  }
+
+  if (!opts) opts = {};
+  if (!opts.enter) opts.enter = function () { };
+  if (!opts.exit) opts.exit = function () { };
+
+  // array of nodes
+  if (Array.isArray(parent)) {
+    for (var i = 0; i < parent.length; i++) {
+      traverse.node(parent[i], opts, scope, state);
+    }
+  } else {
+    traverse.node(parent, opts, scope, state);
+  }
+}
+
+traverse.node = function (node, opts, scope, state, parentPath) {
+  var keys = t.VISITOR_KEYS[node.type];
+  if (!keys) return;
+
+  var context = new TraversalContext(scope, opts, state, parentPath);
+  for (var i = 0; i < keys.length; i++) {
+    if (context.visit(node, keys[i])) {
+      return;
+    }
+  }
+};
+
+function clearNode(node) {
+  node._declarations = null;
+  node.extendedRange = null;
+  node._scopeInfo = null;
+  node.tokens = null;
+  node.range = null;
+  node.start = null;
+  node.end = null;
+  node.loc = null;
+  node.raw = null;
+
+  if (Array.isArray(node.trailingComments)) {
+    clearComments(node.trailingComments);
+  }
+
+  if (Array.isArray(node.leadingComments)) {
+    clearComments(node.leadingComments);
+  }
+}
+
+var clearVisitor = {
+  noScope: true,
+  enter: clearNode
+};
+
+function clearComments(comments) {
+  for (var i = 0; i < comments.length; i++) {
+    clearNode(comments[i]);
+  }
+}
+
+traverse.removeProperties = function (tree) {
+  clearNode(tree);
+  traverse(tree, clearVisitor);
+
+  return tree;
+};
+
+traverse.explode = function (obj) {
+  for (var type in obj) {
+    var fns = obj[type];
+
+    var aliases = t.FLIPPED_ALIAS_KEYS[type];
+    if (aliases) {
+      for (var i = 0; i < aliases.length; i++) {
+        obj[aliases[i]] = fns;
+      }
+    }
+  }
+  return obj;
+};
+
+function hasBlacklistedType(node, parent, scope, state) {
+  if (node.type === state.type) {
+    state.has = true;
+    this.skip();
+  }
+}
+
+traverse.hasType = function (tree, scope, type, blacklistTypes) {
+  // the node we're searching in is blacklisted
+  if (includes(blacklistTypes, tree.type)) return false;
+
+  // the type we're looking for is the same as the passed node
+  if (tree.type === type) return true;
+
+  var state = {
+    has:  false,
+    type: type
+  };
+
+  traverse(tree, {
+    blacklist: blacklistTypes,
+    enter: hasBlacklistedType
+  }, scope, state);
+
+  return state.has;
+};
+
+},{"../types":119,"./context":113,"lodash/collection/includes":200}],115:[function(require,module,exports){
+"use strict";
+
+module.exports = TraversalPath;
+
+var traverse = require("./index");
+var includes = require("lodash/collection/includes");
+var Scope    = require("./scope");
+var t        = require("../types");
+
+function TraversalPath(context, parent, container, key) {
+  this.shouldRemove = false;
+  this.shouldSkip   = false;
+  this.shouldStop   = false;
+
+  this.parentPath = context.parentPath;
+  this.context    = context;
+  this.state      = this.context.state;
+  this.opts       = this.context.opts;
+
+  this.container = container;
+  this.key       = key;
+
+  this.parent = parent;
+  this.state  = context.state;
+
+  this.setScope();
+}
+
+TraversalPath.getScope = function (node, parent, scope) {
+  var ourScope = scope;
+
+  // we're entering a new scope so let's construct it!
+  if (t.isScope(node, parent)) {
+    ourScope = new Scope(node, parent, scope);
+  }
+
+  return ourScope;
+};
+
+TraversalPath.prototype.setScope = function () {
+  this.scope = TraversalPath.getScope(this.node, this.parent, this.context.scope);
+};
+
+TraversalPath.prototype.remove = function () {
+  this.shouldRemove = true;
+  this.shouldSkip   = true;
+};
+
+TraversalPath.prototype.skip = function () {
+  this.shouldSkip = true;
+};
+
+TraversalPath.prototype.stop = function () {
+  this.shouldStop = true;
+  this.shouldSkip = true;
+};
+
+TraversalPath.prototype.flatten = function () {
+  this.context.flatten();
+};
+
+Object.defineProperty(TraversalPath.prototype, "node", {
+  get: function () {
+    return this.container[this.key];
+  },
+
+  set: function (replacement) {
+    var isArray = Array.isArray(replacement);
+
+    // inherit comments from original node to the first replacement node
+    var inheritTo = replacement;
+    if (isArray) inheritTo = replacement[0];
+    if (inheritTo) t.inheritsComments(inheritTo, this.node);
+
+    // replace the node
+    this.container[this.key] = replacement;
+    this.setScope();
+
+    var file = this.scope && this.scope.file;
+    if (file) {
+      if (isArray) {
+        for (var i = 0; i < replacement.length; i++) {
+          file.checkNode(replacement[i], this.scope);
+        }
+      } else {
+        file.checkNode(replacement, this.scope);
+      }
+    }
+
+    // we're replacing a statement or block node with an array of statements so we better
+    // ensure that it's a block
+    if (isArray) {
+      if (includes(t.STATEMENT_OR_BLOCK_KEYS, this.key) && !t.isBlockStatement(this.container)) {
+        t.ensureBlock(this.container, this.key);
+      }
+
+      this.flatten();
+    }
+  }
+});
+
+TraversalPath.prototype.call = function (key) {
+  var node = this.node;
+  if (!node) return;
+
+  var opts = this.opts;
+  var fn   = opts[key] || opts;
+  if (opts[node.type]) fn = opts[node.type][key] || fn;
+
+  var replacement = fn.call(this, node, this.parent, this.scope, this.state);
+
+  if (replacement) {
+    this.node = replacement;
+  }
+
+  if (this.shouldRemove) {
+    this.container[this.key] = null;
+    this.flatten();
+  }
+};
+
+TraversalPath.prototype.visit = function () {
+  var opts = this.opts;
+  var node = this.node;
+
+  // type is blacklisted
+  if (opts.blacklist && opts.blacklist.indexOf(node.type) > -1) {
+    return;
+  }
+
+  this.call("enter");
+
+  if (this.shouldSkip) {
+    return this.shouldStop;
+  }
+
+  node = this.node;
+
+  if (Array.isArray(node)) {
+    // traverse over these replacement nodes we purposely don't call exitNode
+    // as the original node has been destroyed
+    for (var i = 0; i < node.length; i++) {
+      traverse.node(node[i], opts, this.scope, this.state, this);
+    }
+  } else {
+    traverse.node(node, opts, this.scope, this.state, this);
+    this.call("exit");
+  }
+
+  return this.shouldStop;
+};
+
+TraversalPath.prototype.isReferencedIdentifier = function () {
+  return t.isReferencedIdentifier(this.node);
+};
+
+},{"../types":119,"./index":114,"./scope":116,"lodash/collection/includes":200}],116:[function(require,module,exports){
+"use strict";
+
+module.exports = Scope;
+
+var includes = require("lodash/collection/includes");
+var traverse = require("./index");
+var defaults = require("lodash/object/defaults");
+var messages = require("../messages");
+var globals  = require("globals");
+var flatten  = require("lodash/array/flatten");
+var extend   = require("lodash/object/extend");
+var object   = require("../helpers/object");
+var each     = require("lodash/collection/each");
+var t        = require("../types");
+
+/**
+ * This searches the current "scope" and collects all references/bindings
+ * within.
+ *
+ * @param {Node} block
+ * @param {Node} parentBlock
+ * @param {Scope} [parent]
+ * @param {File} [file]
+ */
+
+function Scope(block, parentBlock, parent, file) {
+  this.parent = parent;
+  this.file   = parent ? parent.file : file;
+
+  this.parentBlock = parentBlock;
+  this.block       = block;
+
+  this.crawl();
+}
+
+Scope.globals = flatten([globals.builtin, globals.browser, globals.node].map(Object.keys));
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Object} opts
+ * @param [state]
+ */
+
+Scope.prototype.traverse = function (node, opts, state) {
+  traverse(node, opts, this, state);
+};
+
+/**
+ * Description
+ *
+ * @param {String} [name="temp"]
+ */
+
+Scope.prototype.generateTemp = function (name) {
+  var id = this.generateUidIdentifier(name || "temp");
+  this.push({
+    key: id.name,
+    id: id
+  });
+  return id;
+};
+
+/**
+ * Description
+ *
+ * @param {String} name
+ */
+
+Scope.prototype.generateUidIdentifier = function (name) {
+  var id = t.identifier(this.generateUid(name));
+  this.getFunctionParent().registerBinding("uid", id);
+  return id;
+};
+
+/**
+ * Description
+ *
+ * @param {String} name
+ */
+
+Scope.prototype.generateUid = function (name) {
+  name = t.toIdentifier(name).replace(/^_+/, "");
+
+  var uid;
+  var i = 0;
+  do {
+    uid = this._generateUid(name, i);
+    i++;
+  } while (this.hasBinding(uid) || this.hasGlobal(uid));
+  return uid;
+};
+
+Scope.prototype._generateUid = function (name, i) {
+  var id = name;
+  if (i > 1) id += i;
+  return "_" + id;
+};
+
+/*
+ * Description
+ *
+ * @param {Object} parent
+ * @returns {Object}
+ */
+
+Scope.prototype.generateUidBasedOnNode = function (parent) {
+  var node = parent;
+
+  if (t.isAssignmentExpression(parent)) {
+    node = parent.left;
+  } else if (t.isVariableDeclarator(parent)) {
+    node = parent.id;
+  } else if (t.isProperty(node)) {
+    node = node.key;
+  }
+
+  var parts = [];
+
+  var add = function (node) {
+    if (t.isMemberExpression(node)) {
+      add(node.object);
+      add(node.property);
+    } else if (t.isIdentifier(node)) {
+      parts.push(node.name);
+    } else if (t.isLiteral(node)) {
+      parts.push(node.value);
+    } else if (t.isCallExpression(node)) {
+      add(node.callee);
+    }
+  };
+
+  add(node);
+
+  var id = parts.join("$");
+  id = id.replace(/^_/, "") || "ref";
+
+  return this.generateUidIdentifier(id);
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Object}
+ */
+
+Scope.prototype.generateTempBasedOnNode = function (node) {
+  if (t.isIdentifier(node) && this.hasBinding(node.name)) {
+    return null;
+  }
+
+  var id = this.generateUidBasedOnNode(node);
+  this.push({
+    key: id.name,
+    id: id
+  });
+  return id;
+};
+
+Scope.prototype.checkBlockScopedCollisions = function (kind, name, id) {
+  var local = this.getOwnBindingInfo(name);
+  if (!local) return;
+
+  if (kind === "param") return;
+  if (kind === "hoisted" && local.kind === "let") return;
+
+  if (local.kind === "let" || local.kind === "const" || local.kind === "module") {
+    throw this.file.errorWithNode(id, messages.get("scopeDuplicateDeclaration", name), TypeError);
+  }
+};
+
+Scope.prototype.rename = function (oldName, newName) {
+  newName = newName || this.generateUidIdentifier(oldName).name;
+
+  var info = this.getBindingInfo(oldName);
+  if (!info) return;
+
+  var binding = info.identifier;
+  var scope = info.scope;
+
+  scope.traverse(scope.block, {
+    enter: function (node, parent, scope) {
+      if (t.isReferencedIdentifier(node, parent) && node.name === oldName) {
+        node.name = newName;
+      } else if (t.isDeclaration(node)) {
+        var ids = t.getBindingIdentifiers(node);
+        for (var name in ids) {
+          if (name === oldName) ids[name].name = newName;
+        }
+      } else if (t.isScope(node, parent)) {
+        if (!scope.bindingIdentifierEquals(oldName, binding)) {
+          this.skip();
+        }
+      }
+    }
+  });
+
+  this.clearOwnBinding(oldName);
+  scope.bindings[newName] = info;
+
+  binding.name = newName;
+};
+
+Scope.prototype.inferType = function (node) {
+  var target;
+
+  if (t.isVariableDeclarator(node)) {
+    target = node.init;
+  }
+
+  if (t.isArrayExpression(target)) {
+    return t.genericTypeAnnotation(t.identifier("Array"));
+  }
+
+  if (t.isObjectExpression(target)) {
+    return;
+  }
+
+  if (t.isLiteral(target)) {
+    return;
+  }
+
+  if (t.isCallExpression(target) && t.isIdentifier(target.callee)) {
+    var funcInfo = this.getBindingInfo(target.callee.name);
+    if (funcInfo) {
+      var funcNode = funcInfo.node;
+      return !funcInfo.reassigned && t.isFunction(funcNode) && node.returnType;
+    }
+  }
+
+  if (t.isIdentifier(target)) {
+    return;
+  }
+};
+
+Scope.prototype.isTypeGeneric = function (name, genericName) {
+  var info = this.getBindingInfo(name);
+  if (!info) return false;
+
+  var type = info.typeAnnotation;
+  return t.isGenericTypeAnnotation(type) && t.isIdentifier(type.id, { name: genericName });
+};
+
+Scope.prototype.assignTypeGeneric = function (name, type) {
+  this.assignType(name, t.genericTypeAnnotation(t.identifier(type)));
+};
+
+Scope.prototype.assignType = function (name, type) {
+  var info = this.getBindingInfo(name);
+  if (!info) return;
+
+  info.identifier.typeAnnotation = info.typeAnnotation = type;
+};
+
+Scope.prototype.getTypeAnnotation = function (name, id, node) {
+  var info = {
+    annotation: null,
+    inferred: false
+  };
+
+  var type;
+
+  if (id.typeAnnotation) {
+    type = id.typeAnnotation;
+  }
+
+  if (!type) {
+    info.inferred = true;
+    type = this.inferType(node);
+  }
+
+  if (type) {
+    if (t.isTypeAnnotation(type)) type = type.typeAnnotation;
+    info.annotation = type;
+  }
+
+  return info;
+};
+
+Scope.prototype.toArray = function (node, i) {
+  var file = this.file;
+
+  if (t.isIdentifier(node) && this.isTypeGeneric(node.name, "Array")) {
+    return node;
+  }
+
+  if (t.isArrayExpression(node)) {
+    return node;
+  }
+
+  if (t.isIdentifier(node, { name: "arguments" })) {
+    return t.callExpression(t.memberExpression(file.addHelper("slice"), t.identifier("call")), [node]);
+  }
+
+  var helperName = "to-array";
+  var args = [node];
+  if (i === true) {
+    helperName = "to-consumable-array";
+  } else if (i) {
+    args.push(t.literal(i));
+    helperName = "sliced-to-array";
+  }
+  return t.callExpression(file.addHelper(helperName), args);
+};
+
+Scope.prototype.clearOwnBinding = function (name) {
+  delete this.bindings[name];
+};
+
+Scope.prototype.registerDeclaration = function (node) {
+  if (t.isFunctionDeclaration(node)) {
+    this.registerBinding("hoisted", node);
+  } else if (t.isVariableDeclaration(node)) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      this.registerBinding(node.kind, node.declarations[i]);
+    }
+  } else if (t.isClassDeclaration(node)) {
+    this.registerBinding("let", node);
+  } else if (t.isImportDeclaration(node) || t.isExportDeclaration(node)) {
+    this.registerBinding("module", node);
+  } else {
+    this.registerBinding("unknown", node);
+  }
+};
+
+Scope.prototype.registerBindingReassignment = function (node) {
+  var ids = t.getBindingIdentifiers(node);
+  for (var name in ids) {
+    var info = this.getBindingInfo(name);
+    if (info) {
+      info.reassigned = true;
+
+      if (info.typeAnnotationInferred) {
+        // destroy the inferred typeAnnotation
+        info.typeAnnotation = null;
+      }
+    }
+  }
+};
+
+Scope.prototype.registerBinding = function (kind, node) {
+  if (!kind) throw new ReferenceError("no `kind`");
+
+  var ids = t.getBindingIdentifiers(node);
+
+  for (var name in ids) {
+    var id = ids[name];
+
+    this.checkBlockScopedCollisions(kind, name, id);
+
+    var typeInfo = this.getTypeAnnotation(name, id, node);
+
+    this.bindings[name] = {
+      typeAnnotationInferred: typeInfo.inferred,
+      typeAnnotation:         typeInfo.annotation,
+      reassigned:             false,
+      identifier:             id,
+      scope:                  this,
+      node:                   node,
+      kind:                   kind
+    };
+  }
+};
+
+Scope.prototype.registerVariableDeclaration = function (declar) {
+  var declars = declar.declarations;
+  for (var i = 0; i < declars.length; i++) {
+    this.registerBinding(declars[i], declar.kind);
+  }
+};
+
+var functionVariableVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isFor(node)) {
+      each(t.FOR_INIT_KEYS, function (key) {
+        var declar = node[key];
+        if (t.isVar(declar)) state.scope.registerBinding("var", declar);
+      });
+    }
+
+    // this block is a function so we'll stop since none of the variables
+    // declared within are accessible
+    if (t.isFunction(node)) return this.skip();
+
+    // function identifier doesn't belong to this scope
+    if (state.blockId && node === state.blockId) return;
+
+    // delegate block scope handling to the `blockVariableVisitor`
+    if (t.isBlockScoped(node)) return;
+
+    // this will be hit again once we traverse into it after this iteration
+    if (t.isExportDeclaration(node) && t.isDeclaration(node.declaration)) return;
+
+    // we've ran into a declaration!
+    if (t.isDeclaration(node)) state.scope.registerDeclaration(node);
+  }
+};
+
+Scope.prototype.addGlobal = function (node) {
+  this.globals[node.name] = node;
+};
+
+Scope.prototype.hasGlobal = function (name) {
+  var scope = this;
+
+  do {
+    if (scope.globals[name]) return true;
+  } while (scope = scope.parent);
+
+  return false;
+};
+
+var programReferenceVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isReferencedIdentifier(node, parent) && !scope.hasBinding(node.name)) {
+      state.addGlobal(node);
+    } else if (t.isLabeledStatement(node)) {
+      state.addGlobal(node);
+    } else if (t.isAssignmentExpression(node) || t.isUpdateExpression(node) || (t.isUnaryExpression(node) && node.operator === "delete")) {
+      scope.registerBindingReassignment(node);
+    }
+  }
+};
+
+var blockVariableVisitor = {
+  enter: function (node, parent, scope, state) {
+    if (t.isFunctionDeclaration(node) || t.isBlockScoped(node)) {
+      state.registerDeclaration(node);
+    } else if (t.isScope(node, parent)) {
+      this.skip();
+    }
+  }
+};
+
+Scope.prototype.crawl = function () {
+  var block  = this.block;
+  var i;
+
+  //
+
+  var info = block._scopeInfo;
+  if (info) {
+    extend(this, info);
+    return;
+  }
+
+  info = block._scopeInfo = {
+    bindings: object(),
+    globals:  object()
+  };
+
+  extend(this, info);
+
+  // ForStatement - left, init
+
+  if (t.isLoop(block)) {
+    for (i = 0; i < t.FOR_INIT_KEYS.length; i++) {
+      var node = block[t.FOR_INIT_KEYS[i]];
+      if (t.isBlockScoped(node)) this.registerBinding("let", node);
+    }
+
+    if (t.isBlockStatement(block.body)) {
+      block = block.body;
+    }
+  }
+
+  // FunctionExpression - id
+
+  if (t.isFunctionExpression(block) && block.id) {
+    if (!t.isProperty(this.parentBlock, { method: true })) {
+      this.registerBinding("var", block.id);
+    }
+  }
+
+  // Function - params, rest
+
+  if (t.isFunction(block)) {
+    for (i = 0; i < block.params.length; i++) {
+      this.registerBinding("param", block.params[i]);
+    }
+    this.traverse(block.body, blockVariableVisitor, this);
+  }
+
+  // Program, BlockStatement, Function - let variables
+
+  if (t.isBlockStatement(block) || t.isProgram(block)) {
+    this.traverse(block, blockVariableVisitor, this);
+  }
+
+  // CatchClause - param
+
+  if (t.isCatchClause(block)) {
+    this.registerBinding("let", block.param);
+  }
+
+  // ComprehensionExpression - blocks
+
+  if (t.isComprehensionExpression(block)) {
+    this.registerBinding("let", block);
+  }
+
+  // Program, Function - var variables
+
+  if (t.isProgram(block) || t.isFunction(block)) {
+    this.traverse(block, functionVariableVisitor, {
+      blockId: block.id,
+      scope:   this
+    });
+  }
+
+  // Program
+
+  if (t.isProgram(block)) {
+    this.traverse(block, programReferenceVisitor, this);
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Object} opts
+ */
+
+Scope.prototype.push = function (opts) {
+  var block = this.block;
+
+  if (t.isLoop(block) || t.isCatchClause(block) || t.isFunction(block)) {
+    t.ensureBlock(block);
+    block = block.body;
+  }
+
+  if (t.isBlockStatement(block) || t.isProgram(block)) {
+    block._declarations = block._declarations || {};
+    block._declarations[opts.key] = {
+      kind: opts.kind,
+      id: opts.id,
+      init: opts.init
+    };
+  } else {
+    throw new TypeError("cannot add a declaration here in node type " + block.type);
+  }
+};
+
+/**
+ * Walk up the scope tree until we hit either a Function or reach the
+ * very top and hit Program.
+ */
+
+Scope.prototype.getFunctionParent = function () {
+  var scope = this;
+  while (scope.parent && !t.isFunction(scope.block)) {
+    scope = scope.parent;
+  }
+  return scope;
+};
+
+/**
+ * Walks the scope tree and gathers **all** bindings.
+ *
+ * @returns {Object}
+ */
+
+Scope.prototype.getAllBindings = function () {
+  var ids = object();
+
+  var scope = this;
+  do {
+    defaults(ids, scope.bindings);
+    scope = scope.parent;
+  } while (scope);
+
+  return ids;
+};
+
+/**
+ * Walks the scope tree and gathers all declarations of `kind`.
+ *
+ * @param {String} kind
+ * @returns {Object}
+ */
+
+Scope.prototype.getAllBindingsOfKind = function (kind) {
+  var ids = object();
+
+  var scope = this;
+  do {
+    for (var name in scope.bindings) {
+      var binding = scope.bindings[name];
+      if (binding.kind === kind) ids[name] = binding;
+    }
+    scope = scope.parent;
+  } while (scope);
+
+  return ids;
+};
+
+// misc
+
+Scope.prototype.bindingIdentifierEquals = function (name, node) {
+  return this.getBindingIdentifier(name) === node;
+};
+
+// get
+
+Scope.prototype.getBindingInfo = function (name) {
+  var scope = this;
+
+  do {
+    var binding = scope.getOwnBindingInfo(name);
+    if (binding) return binding;
+  } while (scope = scope.parent);
+};
+
+Scope.prototype.getOwnBindingInfo = function (name) {
+  return this.bindings[name];
+};
+
+Scope.prototype.getBindingIdentifier = function (name) {
+  var info = this.getBindingInfo(name);
+  return info && info.identifier;
+};
+
+Scope.prototype.getOwnBindingIdentifier = function (name) {
+  var binding = this.bindings[name];
+  return binding && binding.identifier;
+};
+
+// has
+
+Scope.prototype.hasOwnBinding = function (name) {
+  return !!this.getOwnBindingInfo(name);
+};
+
+Scope.prototype.hasBinding = function (name) {
+  if (!name) return false;
+  if (this.hasOwnBinding(name)) return true;
+  if (this.parentHasBinding(name)) return true;
+  if (includes(Scope.globals, name)) return true;
+  return false;
+};
+
+Scope.prototype.parentHasBinding = function (name) {
+  return this.parent && this.parent.hasBinding(name);
+};
+
+},{"../helpers/object":24,"../messages":27,"../types":119,"./index":114,"globals":183,"lodash/array/flatten":192,"lodash/collection/each":197,"lodash/collection/includes":200,"lodash/object/defaults":294,"lodash/object/extend":295}],117:[function(require,module,exports){
+module.exports={
+  "ExpressionStatement": ["Statement"],
+  "BreakStatement":      ["Statement"],
+  "ContinueStatement":   ["Statement"],
+  "DebuggerStatement":   ["Statement"],
+  "DoWhileStatement":    ["Statement", "Loop", "While", "Scopable"],
+  "IfStatement":         ["Statement"],
+  "ReturnStatement":     ["Statement"],
+  "SwitchStatement":     ["Statement"],
+  "ThrowStatement":      ["Statement"],
+  "TryStatement":        ["Statement"],
+  "WhileStatement":      ["Statement", "Loop", "While", "Scopable"],
+  "WithStatement":       ["Statement"],
+  "EmptyStatement":      ["Statement"],
+  "LabeledStatement":    ["Statement"],
+  "VariableDeclaration": ["Statement", "Declaration"],
+  "ExportDeclaration":   ["Statement", "Declaration"],
+  "ImportDeclaration":   ["Statement", "Declaration"],
+  "PrivateDeclaration":  ["Statement", "Declaration"],
+
+  "ArrowFunctionExpression": ["Scopable", "Function", "Expression"],
+  "FunctionDeclaration":     ["Scopable", "Function", "Statement", "Declaration"],
+  "FunctionExpression":      ["Scopable", "Function", "Expression"],
+
+  "ImportSpecifier": ["ModuleSpecifier"],
+  "ExportSpecifier": ["ModuleSpecifier"],
+
+  "BlockStatement": ["Statement", "Scopable"],
+  "Program":        ["Scopable"],
+  "CatchClause":    ["Scopable"],
+
+  "LogicalExpression": ["Binary", "Expression"],
+  "BinaryExpression":  ["Binary", "Expression"],
+
+  "UnaryExpression": ["UnaryLike", "Expression"],
+  "SpreadProperty":  ["UnaryLike"],
+  "SpreadElement":   ["UnaryLike"],
+
+  "ClassDeclaration": ["Statement", "Declaration", "Class"],
+  "ClassExpression":  ["Class", "Expression"],
+
+  "ForOfStatement": ["Scopable", "Statement", "For", "Loop"],
+  "ForInStatement": ["Scopable", "Statement", "For", "Loop"],
+  "ForStatement":   ["Scopable", "Statement", "For", "Loop"],
+
+  "ObjectPattern":     ["Pattern"],
+  "ArrayPattern":      ["Pattern"],
+  "AssignmentPattern": ["Pattern"],
+
+  "Property":   ["UserWhitespacable"],
+
+  "ArrayExpression":           ["Expression"],
+  "AssignmentExpression":      ["Expression"],
+  "AwaitExpression":           ["Expression"],
+  "BindFunctionExpression":    ["Expression"],
+  "BindMemberExpression":      ["Expression"],
+  "CallExpression":            ["Expression"],
+  "ComprehensionExpression":   ["Expression", "Scopable"],
+  "ConditionalExpression":     ["Expression"],
+  "Identifier":                ["Expression"],
+  "Literal":                   ["Expression"],
+  "MemberExpression":          ["Expression"],
+  "NewExpression":             ["Expression"],
+  "ObjectExpression":          ["Expression"],
+  "SequenceExpression":        ["Expression"],
+  "TaggedTemplateExpression":  ["Expression"],
+  "ThisExpression":            ["Expression"],
+  "UpdateExpression":          ["Expression"],
+  "VirtualPropertyExpression": ["Expression"],
+  "JSXEmptyExpression":        ["Expression"],
+  "JSXMemberExpression":       ["Expression"],
+  "YieldExpression":           ["Expression"],
+
+  "JSXAttribute":           ["JSX"],
+  "JSXClosingElement":      ["JSX"],
+  "JSXElement":             ["JSX", "Expression"],
+  "JSXEmptyExpression":     ["JSX"],
+  "JSXExpressionContainer": ["JSX"],
+  "JSXIdentifier":          ["JSX"],
+  "JSXMemberExpression":    ["JSX"],
+  "JSXNamespacedName":      ["JSX"],
+  "JSXOpeningElement":      ["JSX"],
+  "JSXSpreadAttribute":     ["JSX"]
+}
+
+},{}],118:[function(require,module,exports){
+module.exports={
+  "ArrayExpression": {
+    "elements": null
+  },
+
+  "ArrowFunctionExpression": {
+    "params": null,
+    "body": null
+  },
+
+  "AssignmentExpression": {
+    "operator": null,
+    "left": null,
+    "right": null
+  },
+
+  "BinaryExpression": {
+    "operator": null,
+    "left": null,
+    "right": null
+  },
+
+  "BlockStatement": {
+    "body": null
+  },
+
+  "CallExpression": {
+    "callee": null,
+    "arguments": null
+  },
+
+  "ConditionalExpression": {
+    "test": null,
+    "consequent": null,
+    "alternate": null
+  },
+
+  "ExpressionStatement": {
+    "expression": null
+  },
+
+  "File": {
+    "program": null,
+    "comments": null,
+    "tokens": null
+  },
+
+  "FunctionExpression": {
+    "id": null,
+    "params": null,
+    "body": null,
+    "generator": false
+  },
+
+  "FunctionDeclaration": {
+    "id": null,
+    "params": null,
+    "body": null,
+    "generator": false
+  },
+
+  "GenericTypeAnnotation": {
+    "id": null,
+    "typeParameters": null
+  },
+
+  "Identifier": {
+    "name": null
+  },
+
+  "IfStatement": {
+    "test": null,
+    "consequent": null,
+    "alternate": null
+  },
+
+  "ImportDeclaration": {
+    "specifiers": null,
+    "source": null
+  },
+
+  "ImportSpecifier": {
+    "id": null,
+    "name": null
+  },
+
+  "Literal": {
+    "value": null
+  },
+
+  "LogicalExpression": {
+    "operator": null,
+    "left": null,
+    "right": null
+  },
+
+  "MemberExpression": {
+    "object": null,
+    "property": null,
+    "computed": false
+  },
+
+  "MethodDefinition": {
+    "key": null,
+    "value": null,
+    "computed": false,
+    "static": false,
+    "kind": null
+  },
+
+  "NewExpression": {
+    "callee": null,
+    "arguments": null
+  },
+
+  "ObjectExpression": {
+    "properties": null
+  },
+
+  "Program": {
+    "body": null
+  },
+
+  "Property": {
+    "kind": null,
+    "key": null,
+    "value": null,
+    "computed": false
+  },
+
+  "ReturnStatement": {
+    "argument": null
+  },
+
+  "SequenceExpression": {
+    "expressions": null
+  },
+
+  "ThrowExpression": {
+    "argument": null
+  },
+
+  "UnaryExpression": {
+    "operator": null,
+    "argument": null,
+    "prefix": null
+  },
+
+  "VariableDeclaration": {
+    "kind": null,
+    "declarations": null
+  },
+
+  "VariableDeclarator": {
+    "id": null,
+    "init": null
+  },
+
+  "WithStatement": {
+    "object": null,
+    "body": null
+  },
+
+  "YieldExpression": {
+    "argument": null,
+    "delegate": null
+  }
+}
+
+},{}],119:[function(require,module,exports){
+"use strict";
+
+var toFastProperties = require("../helpers/to-fast-properties");
+var isString         = require("lodash/lang/isString");
+var compact          = require("lodash/array/compact");
+var esutils          = require("esutils");
+var object           = require("../helpers/object");
+var each             = require("lodash/collection/each");
+var uniq             = require("lodash/array/uniq");
+
+var t = exports;
+
+/**
+ * Registers `is[Type]` and `assert[Type]` generated functions for a given `type`.
+ * Pass `skipAliasCheck` to force it to directly compare `node.type` with `type`.
+ *
+ * @param {String} type
+ * @param {Boolean?} skipAliasCheck
+ */
+
+function registerType(type, skipAliasCheck) {
+  var is = t["is" + type] = function (node, opts) {
+    return t.is(type, node, opts, skipAliasCheck);
+  };
+
+  t["assert" + type] = function (node, opts) {
+    opts = opts || {};
+    if (!is(node, opts)) {
+      throw new Error("Expected type " + JSON.stringify(type) + " with option " + JSON.stringify(opts));
+    }
+  };
+}
+
+t.STATEMENT_OR_BLOCK_KEYS = ["consequent", "body"];
+t.NATIVE_TYPE_NAMES       = ["Array", "Object", "Number", "Boolean", "Date", "Array", "String"];
+t.FOR_INIT_KEYS           = ["left", "init"];
+
+t.VISITOR_KEYS = require("./visitor-keys");
+t.ALIAS_KEYS   = require("./alias-keys");
+
+t.FLIPPED_ALIAS_KEYS = {};
+
+each(t.VISITOR_KEYS, function (keys, type) {
+  registerType(type, true);
+});
+
+each(t.ALIAS_KEYS, function (aliases, type) {
+  each(aliases, function (alias) {
+    var types = t.FLIPPED_ALIAS_KEYS[alias] = t.FLIPPED_ALIAS_KEYS[alias] || [];
+    types.push(type);
+  });
+});
+
+each(t.FLIPPED_ALIAS_KEYS, function (types, type) {
+  t[type.toUpperCase() + "_TYPES"] = types;
+  registerType(type, false);
+});
+
+/**
+ * Returns whether `node` is of given `type`.
+ *
+ * For better performance, use this instead of `is[Type]` when `type` is unknown.
+ * Optionally, pass `skipAliasCheck` to directly compare `node.type` with `type`.
+ *
+ * @param {String} type
+ * @param {Node} node
+ * @param {Object?} opts
+ * @param {Boolean?} skipAliasCheck
+ * @returns {Boolean} isOfType
+ */
+
+t.is = function (type, node, opts, skipAliasCheck) {
+  if (!node) return false;
+
+  var typeMatches = type === node.type;
+
+  if (!typeMatches && !skipAliasCheck) {
+    var aliases = t.FLIPPED_ALIAS_KEYS[type];
+
+    if (typeof aliases !== "undefined") {
+      typeMatches = aliases.indexOf(node.type) > -1;
+    }
+  }
+
+  if (!typeMatches) {
+    return false;
+  }
+
+  if (typeof opts !== "undefined") {
+    return t.shallowEqual(node, opts);
+  }
+
+  return true;
+};
+
+//
+
+t.BUILDER_KEYS = require("./builder-keys");
+
+each(t.VISITOR_KEYS, function (keys, type) {
+  if (t.BUILDER_KEYS[type]) return;
+
+  var defs = {};
+  each(keys, function (key) {
+    defs[key] = null;
+  });
+  t.BUILDER_KEYS[type] = defs;
+});
+
+each(t.BUILDER_KEYS, function (keys, type) {
+  t[type[0].toLowerCase() + type.slice(1)] = function () {
+    var node = {};
+    node.start = null;
+    node.type = type;
+
+    var i = 0;
+
+    for (var key in keys) {
+      var arg = arguments[i++];
+      if (arg === undefined) arg = keys[key];
+      node[key] = arg;
+    }
+
+    return node;
+  };
+});
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Object}
+ */
+
+t.toComputedKey = function (node, key) {
+  if (!node.computed) {
+    if (t.isIdentifier(key)) key = t.literal(key.name);
+  }
+  return key;
+};
+
+/*
+ * Shallowly checks to see if the passed `node` is falsy.
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
+
+t.isFalsyExpression = function (node) {
+  if (t.isLiteral(node)) {
+    return !node.value;
+  } else if (t.isIdentifier(node)) {
+    return node.name === "undefined";
+  }
+  return false;
+};
+
+/**
+ * Turn an array of statement `nodes` into a `SequenceExpression`.
+ *
+ * Variable declarations are turned into simple assignments and their
+ * declarations hoisted to the top of the current scope.
+ *
+ * Expression statements are just resolved to their standard expression.
+ *
+ * @param {Array} nodes
+ * @param {Scope} scope
+ */
+
+t.toSequenceExpression = function (nodes, scope) {
+  var exprs = [];
+
+  each(nodes, function (node) {
+    if (t.isExpression(node)) {
+      exprs.push(node);
+    } if (t.isExpressionStatement(node)) {
+      exprs.push(node.expression);
+    } else if (t.isVariableDeclaration(node)) {
+      each(node.declarations, function (declar) {
+        scope.push({
+          kind: node.kind,
+          key: declar.id.name,
+          id: declar.id
+        });
+        exprs.push(t.assignmentExpression("=", declar.id, declar.init));
+      });
+    }
+  });
+
+  if (exprs.length === 1) {
+    return exprs[0];
+  } else {
+    return t.sequenceExpression(exprs);
+  }
+};
+
+/*
+ * Description
+ *
+ * @param {Object} actual
+ * @param {Object} expected
+ * @returns {Boolean}
+ */
+
+t.shallowEqual = function (actual, expected) {
+  var keys = Object.keys(expected);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+
+    if (actual[key] !== expected[key]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} member
+ * @param {Object} append
+ * @param {Boolean} [computed]
+ * @returns {Object} member
+ */
+
+t.appendToMemberExpression = function (member, append, computed) {
+  member.object   = t.memberExpression(member.object, member.property, member.computed);
+  member.property = append;
+  member.computed = !!computed;
+  return member;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} member
+ * @param {Object} append
+ * @returns {Object} member
+ */
+
+t.prependToMemberExpression = function (member, append) {
+  member.object = t.memberExpression(append, member.object);
+  return member;
+};
+
+/**
+ * Check if the input `node` is a reference to a bound variable.
+ *
+ * @param {Object} node
+ * @param {Object} parent
+ * @returns {Boolean}
+ */
+
+t.isReferenced = function (node, parent) {
+  // yes: PARENT[NODE]
+  // yes: NODE.child
+  // no: parent.CHILD
+  if (t.isMemberExpression(parent)) {
+    if (parent.property === node && parent.computed) {
+      return true;
+    } else if (parent.object === node) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // yes: { [NODE]: "" }
+  // no: { NODE: "" }
+  if (t.isProperty(parent) && parent.key === node) {
+    return parent.computed;
+  }
+
+  // no: var NODE = init;
+  // yes: var id = NODE;
+  if (t.isVariableDeclarator(parent)) {
+    return parent.id !== node;
+  }
+
+  // no: function NODE() {}
+  // no: function foo(NODE) {}
+  if (t.isFunction(parent)) {
+    for (var i = 0; i < parent.params.length; i++) {
+      var param = parent.params[i];
+      if (param === node) return false;
+    }
+
+    return parent.id !== node;
+  }
+
+  // no: class NODE {}
+  if (t.isClass(parent)) {
+    return parent.id !== node;
+  }
+
+  // yes: class { [NODE](){} }
+  if (t.isMethodDefinition(parent)) {
+    return parent.key === node && parent.computed;
+  }
+
+  // no: NODE: for (;;) {}
+  if (t.isLabeledStatement(parent)) {
+    return false;
+  }
+
+  // no: try {} catch (NODE) {}
+  if (t.isCatchClause(parent)) {
+    return parent.param !== node;
+  }
+
+  // no: function foo(...NODE) {}
+  if (t.isRestElement(parent)) {
+    return false;
+  }
+
+  // no: [NODE = foo] = [];
+  // yes: [foo = NODE] = [];
+  if (t.isAssignmentPattern(parent)) {
+    return parent.right === node;
+  }
+
+  // no: [NODE] = [];
+  // no: ({ NODE }) = [];
+  if (t.isPattern(parent)) {
+    return false;
+  }
+
+  // no: import NODE from "bar";
+  if (t.isImportSpecifier(parent)) {
+    return false;
+  }
+
+  // no: import * as NODE from "foo";
+  if (t.isImportBatchSpecifier(parent)) {
+    return false;
+  }
+
+  // no: class Foo { private NODE; }
+  if (t.isPrivateDeclaration(parent)) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Check if the input `node` is an `Identifier` and `isReferenced`.
+ *
+ * @param {Node} node
+ * @parma {Node} parent
+ * @returns {Boolean}
+ */
+
+t.isReferencedIdentifier = function (node, parent, opts) {
+  return t.isIdentifier(node, opts) && t.isReferenced(node, parent);
+};
+
+/**
+ * Check if the input `name` is a valid identifier name
+ * and isn't a reserved word.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ */
+
+t.isValidIdentifier = function (name) {
+  return isString(name) && esutils.keyword.isIdentifierName(name) && !esutils.keyword.isReservedWordES6(name, true);
+};
+
+/*
+ * Description
+ *
+ * @param {String} name
+ * @returns {String}
+ */
+
+t.toIdentifier = function (name) {
+  if (t.isIdentifier(name)) return name.name;
+
+  name = name + "";
+
+  // replace all non-valid identifiers with dashes
+  name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
+
+  // remove all dashes and numbers from start of name
+  name = name.replace(/^[-0-9]+/, "");
+
+  // camel case
+  name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+    return c ? c.toUpperCase() : "";
+  });
+
+  if (!t.isValidIdentifier(name)) {
+    name = "_" + name;
+  }
+
+  return name || "_";
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {String=} key
+ */
+
+t.ensureBlock = function (node, key) {
+  key = key || "body";
+  return node[key] = t.toBlock(node[key], node);
+};
+
+/**
+ * Build a function that when called will return whether or not the
+ * input `node` `MemberExpression` matches the input `match`.
+ *
+ * For example, given the match `React.createClass` it would match the
+ * parsed nodes of `React.createClass` and `React["createClass"]`.
+ *
+ * @param {String} match Dot-delimited string
+ * @param {Boolean} [allowPartial] Allow a partial match
+ * @returns {Function}
+ */
+
+t.buildMatchMemberExpression = function (match, allowPartial) {
+  var parts = match.split(".");
+
+  return function (member) {
+    // not a member expression
+    if (!t.isMemberExpression(member)) return false;
+
+    var search = [member];
+    var i = 0;
+
+    while (search.length) {
+      var node = search.shift();
+
+      if (allowPartial && i === parts.length) {
+        return true;
+      }
+
+      if (t.isIdentifier(node)) {
+        // this part doesn't match
+        if (parts[i] !== node.name) return false;
+      } else if (t.isLiteral(node)) {
+        // this part doesn't match
+        if (parts[i] !== node.value) return false;
+      } else if (t.isMemberExpression(node)) {
+        if (node.computed && !t.isLiteral(node.property)) {
+          // we can't deal with this
+          return false;
+        } else {
+          search.push(node.object);
+          search.push(node.property);
+          continue;
+        }
+      } else {
+        // we can't deal with this
+        return false;
+      }
+
+      // too many parts
+      if (++i > parts.length) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Boolean} [ignore]
+ * @returns {Object|Boolean}
+ */
+
+t.toStatement = function (node, ignore) {
+  if (t.isStatement(node)) {
+    return node;
+  }
+
+  var mustHaveId = false;
+  var newType;
+
+  if (t.isClass(node)) {
+    mustHaveId = true;
+    newType = "ClassDeclaration";
+  } else if (t.isFunction(node)) {
+    mustHaveId = true;
+    newType = "FunctionDeclaration";
+  } else if (t.isAssignmentExpression(node)) {
+    return t.expressionStatement(node);
+  }
+
+  if (mustHaveId && !node.id) {
+    newType = false;
+  }
+
+  if (!newType) {
+    if (ignore) {
+      return false;
+    } else {
+      throw new Error("cannot turn " + node.type + " to a statement");
+    }
+  }
+
+  node.type = newType;
+
+  return node;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Object}
+ */
+
+exports.toExpression = function (node) {
+  if (t.isExpressionStatement(node)) {
+    node = node.expression;
+  }
+
+  if (t.isClass(node)) {
+    node.type = "ClassExpression";
+  } else if (t.isFunction(node)) {
+    node.type = "FunctionExpression";
+  }
+
+  if (t.isExpression(node)) {
+    return node;
+  } else {
+    throw new Error("cannot turn " + node.type + " to an expression");
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @param {Object} parent
+ * @returns {Object}
+ */
+
+t.toBlock = function (node, parent) {
+  if (t.isBlockStatement(node)) {
+    return node;
+  }
+
+  if (t.isEmptyStatement(node)) {
+    node = [];
+  }
+
+  if (!Array.isArray(node)) {
+    if (!t.isStatement(node)) {
+      if (t.isFunction(parent)) {
+        node = t.returnStatement(node);
+      } else {
+        node = t.expressionStatement(node);
+      }
+    }
+
+    node = [node];
+  }
+
+  return t.blockStatement(node);
+};
+
+/**
+ * Return a list of binding identifiers associated with
+ * the input `node`.
+ *
+ * @param {Object} node
+ * @returns {Array|Object}
+ */
+
+t.getBindingIdentifiers = function (node) {
+  var search = [].concat(node);
+  var ids    = object();
+
+  while (search.length) {
+    var id = search.shift();
+    if (!id) continue;
+
+    var keys = t.getBindingIdentifiers.keys[id.type];
+
+    if (t.isIdentifier(id)) {
+      ids[id.name] = id;
+    } else if (t.isImportSpecifier(id)) {
+      search.push(id.name || id.id);
+    } else if (t.isExportDeclaration(id)) {
+      if (t.isDeclaration(node.declaration)) {
+        search.push(node.declaration);
+      }
+    } else if (keys) {
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        search = search.concat(id[key] || []);
+      }
+    }
+  }
+
+  return ids;
+};
+
+t.getBindingIdentifiers.keys = {
+  UnaryExpression: ["argument"],
+  AssignmentExpression: ["left"],
+  ImportBatchSpecifier: ["name"],
+  VariableDeclarator: ["id"],
+  FunctionDeclaration: ["id"],
+  ClassDeclaration: ["id"],
+  SpreadElement: ["argument"],
+  RestElement: ["argument"],
+  UpdateExpression: ["argument"],
+  SpreadProperty: ["argument"],
+  Property: ["value"],
+  ComprehensionBlock: ["left"],
+  AssignmentPattern: ["left"],
+  PrivateDeclaration: ["declarations"],
+  ComprehensionExpression: ["blocks"],
+  ImportDeclaration: ["specifiers"],
+  VariableDeclaration: ["declarations"],
+  ArrayPattern: ["elements"],
+  ObjectPattern: ["properties"]
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
+
+t.isLet = function (node) {
+  return t.isVariableDeclaration(node) && (node.kind !== "var" || node._let);
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
+
+t.isBlockScoped = function (node) {
+  return t.isFunctionDeclaration(node) || t.isClassDeclaration(node) || t.isLet(node);
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Boolean}
+ */
+
+t.isVar = function (node) {
+  return t.isVariableDeclaration(node, { kind: "var" }) && !node._let;
+};
+
+//
+
+t.COMMENT_KEYS = ["leadingComments", "trailingComments"];
+
+/**
+ * Description
+ *
+ * @param {Object} child
+ * @returns {Object} child
+ */
+
+t.removeComments = function (child) {
+  each(t.COMMENT_KEYS, function (key) {
+    delete child[key];
+  });
+  return child;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} child
+ * @param {Object} parent
+ * @returns {Object} child
+ */
+
+t.inheritsComments = function (child, parent) {
+  each(t.COMMENT_KEYS, function (key) {
+    child[key]  = uniq(compact([].concat(child[key], parent[key])));
+  });
+  return child;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} child
+ * @param {Object} parent
+ * @returns {Object} child
+ */
+
+t.inherits = function (child, parent) {
+  child._declarations = parent._declarations;
+  child._scopeInfo    = parent._scopeInfo;
+  child.range         = parent.range;
+  child.start         = parent.start;
+  child.loc           = parent.loc;
+  child.end           = parent.end;
+  t.inheritsComments(child, parent);
+  return child;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} node
+ * @returns {Array}
+ */
+
+t.getLastStatements = function (node) {
+  var nodes = [];
+
+  var add = function (node) {
+    nodes = nodes.concat(t.getLastStatements(node));
+  };
+
+  if (t.isIfStatement(node)) {
+    add(node.consequent);
+    add(node.alternate);
+  } else if (t.isFor(node) || t.isWhile(node)) {
+    add(node.body);
+  } else if (t.isProgram(node) || t.isBlockStatement(node)) {
+    add(node.body[node.body.length - 1]);
+  } else if (node) {
+    nodes.push(node);
+  }
+
+  return nodes;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} specifier
+ * @returns {String}
+ */
+
+t.getSpecifierName = function (specifier) {
+  return specifier.name || specifier.id;
+};
+
+/**
+ * Description
+ *
+ * @param {Object} specifier
+ * @returns {String}
+ */
+
+t.getSpecifierId = function (specifier) {
+  if (specifier.default) {
+    return t.identifier("default");
+  } else {
+    return specifier.id;
+  }
+};
+
+/**
+ * Description
+ *
+ * @param {Object} specifier
+ * @returns {Boolean}
+ */
+
+t.isSpecifierDefault = function (specifier) {
+  return specifier.default || t.isIdentifier(specifier.id) && specifier.id.name === "default";
+};
+
+/**
+ * Description
+ *
+ * @param {Node} node
+ * @param {Node} parent
+ * @returns {Boolean}
+ */
+
+t.isScope = function (node, parent) {
+  if (t.isBlockStatement(node)) {
+    if (t.isLoop(parent.block, { body: node })) {
+      return false;
+    }
+
+    if (t.isFunction(parent.block, { body: node })) {
+      return false;
+    }
+  }
+
+  return t.isScopable(node);
+};
+
+toFastProperties(t);
+toFastProperties(t.VISITOR_KEYS);
+
+},{"../helpers/object":24,"../helpers/to-fast-properties":26,"./alias-keys":117,"./builder-keys":118,"./visitor-keys":120,"esutils":181,"lodash/array/compact":191,"lodash/array/uniq":195,"lodash/collection/each":197,"lodash/lang/isString":291}],120:[function(require,module,exports){
+module.exports={
+  "ArrayExpression":           ["elements"],
+  "ArrayPattern":              ["elements"],
+  "ArrowFunctionExpression":   ["params", "defaults", "rest", "body"],
+  "AssignmentExpression":      ["left", "right"],
+  "AssignmentPattern":         ["left", "right"],
+  "AwaitExpression":           ["argument"],
+  "BinaryExpression":          ["left", "right"],
+  "BindFunctionExpression":    ["callee", "arguments"],
+  "BindMemberExpression":      ["object", "property", "arguments"],
+  "BlockStatement":            ["body"],
+  "BreakStatement":            ["label"],
+  "CallExpression":            ["callee", "arguments"],
+  "CatchClause":               ["param", "body"],
+  "ClassBody":                 ["body"],
+  "ClassDeclaration":          ["id", "body", "superClass"],
+  "ClassExpression":           ["id", "body", "superClass"],
+  "ComprehensionBlock":        ["left", "right", "body"],
+  "ComprehensionExpression":   ["filter", "blocks", "body"],
+  "ConditionalExpression":     ["test", "consequent", "alternate"],
+  "ContinueStatement":         ["label"],
+  "DebuggerStatement":         [],
+  "DoWhileStatement":          ["body", "test"],
+  "EmptyStatement":            [],
+  "ExportBatchSpecifier":      [],
+  "ExportDeclaration":         ["declaration", "specifiers", "source"],
+  "ExportSpecifier":           ["id", "name"],
+  "ExpressionStatement":       ["expression"],
+  "File":                      ["program"],
+  "ForInStatement":            ["left", "right", "body"],
+  "ForOfStatement":            ["left", "right", "body"],
+  "ForStatement":              ["init", "test", "update", "body"],
+  "FunctionDeclaration":       ["id", "params", "defaults", "rest", "body"],
+  "FunctionExpression":        ["id", "params", "defaults", "rest", "body"],
+  "Identifier":                [],
+  "IfStatement":               ["test", "consequent", "alternate"],
+  "ImportBatchSpecifier":      ["id"],
+  "ImportDeclaration":         ["specifiers", "source"],
+  "ImportSpecifier":           ["id", "name"],
+  "LabeledStatement":          ["label", "body"],
+  "Literal":                   [],
+  "LogicalExpression":         ["left", "right"],
+  "MemberExpression":          ["object", "property"],
+  "MethodDefinition":          ["key", "value"],
+  "NewExpression":             ["callee", "arguments"],
+  "ObjectExpression":          ["properties"],
+  "ObjectPattern":             ["properties"],
+  "PrivateDeclaration":        ["declarations"],
+  "Program":                   ["body"],
+  "Property":                  ["key", "value"],
+  "RestElement":               ["argument"],
+  "ReturnStatement":           ["argument"],
+  "SequenceExpression":        ["expressions"],
+  "SpreadElement":             ["argument"],
+  "SpreadProperty":            ["argument"],
+  "SwitchCase":                ["test", "consequent"],
+  "SwitchStatement":           ["discriminant", "cases"],
+  "TaggedTemplateExpression":  ["tag", "quasi"],
+  "TemplateElement":           [],
+  "TemplateLiteral":           ["quasis", "expressions"],
+  "ThisExpression":            [],
+  "ThrowStatement":            ["argument"],
+  "TryStatement":              ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
+  "UnaryExpression":           ["argument"],
+  "UpdateExpression":          ["argument"],
+  "VariableDeclaration":       ["declarations"],
+  "VariableDeclarator":        ["id", "init"],
+  "VirtualPropertyExpression": ["object", "property"],
+  "WhileStatement":            ["test", "body"],
+  "WithStatement":             ["object", "body"],
+  "YieldExpression":           ["argument"],
+
+  "AnyTypeAnnotation":           [],
+  "ArrayTypeAnnotation":         [],
+  "BooleanTypeAnnotation":       [],
+  "ClassProperty":               ["key", "value"],
+  "DeclareClass":                [],
+  "DeclareFunction":             [],
+  "DeclareModule":               [],
+  "DeclareVariable":             [],
+  "FunctionTypeAnnotation":      [],
+  "FunctionTypeParam":           [],
+  "GenericTypeAnnotation":       [],
+  "InterfaceExtends":            [],
+  "InterfaceDeclaration":        [],
+  "IntersectionTypeAnnotation":  [],
+  "NullableTypeAnnotation":      [],
+  "NumberTypeAnnotation":        [],
+  "StringLiteralTypeAnnotation": [],
+  "StringTypeAnnotation":        [],
+  "TupleTypeAnnotation":         [],
+  "TypeofTypeAnnotation":        [],
+  "TypeAlias":                   [],
+  "TypeAnnotation":              [],
+  "TypeCastExpression":          ["expression"],
+  "TypeParameterDeclaration":    [],
+  "TypeParameterInstantiation":  [],
+  "ObjectTypeAnnotation":        [],
+  "ObjectTypeCallProperty":      [],
+  "ObjectTypeIndexer":           [],
+  "ObjectTypeProperty":          [],
+  "QualifiedTypeIdentifier":     [],
+  "UnionTypeAnnotation":         [],
+  "VoidTypeAnnotation":          [],
+
+  "JSXAttribute":              ["name", "value"],
+  "JSXClosingElement":         ["name"],
+  "JSXElement":                ["openingElement", "closingElement", "children"],
+  "JSXEmptyExpression":        [],
+  "JSXExpressionContainer":    ["expression"],
+  "JSXIdentifier":             [],
+  "JSXMemberExpression":       ["object", "property"],
+  "JSXNamespacedName":         ["namespace", "name"],
+  "JSXOpeningElement":         ["name", "attributes"],
+  "JSXSpreadAttribute":        ["argument"]
+}
+
+},{}],121:[function(require,module,exports){
+(function (__dirname){
+"use strict";
+
+require("./patch");
+
+var cloneDeep  = require("lodash/lang/cloneDeep");
+var contains   = require("lodash/collection/contains");
+var traverse   = require("./traversal");
+var isString   = require("lodash/lang/isString");
+var isRegExp   = require("lodash/lang/isRegExp");
+var isEmpty    = require("lodash/lang/isEmpty");
+var parse      = require("./helpers/parse");
+var debug      = require("debug/node");
+var path       = require("path");
+var util       = require("util");
+var each       = require("lodash/collection/each");
+var has        = require("lodash/object/has");
+var fs         = require("fs");
+var t          = require("./types");
+
+exports.inherits = util.inherits;
+
+exports.debug = debug("babel");
+
+exports.canCompile = function (filename, altExts) {
+  var exts = altExts || exports.canCompile.EXTENSIONS;
+  var ext = path.extname(filename);
+  return contains(exts, ext);
+};
+
+exports.canCompile.EXTENSIONS = [".js", ".jsx", ".es6", ".es"];
+
+exports.resolve = function (loc) {
+  try {
+    return require.resolve(loc);
+  } catch (err) {
+    return null;
+  }
+};
+
+exports.list = function (val) {
+  return val ? val.split(",") : [];
+};
+
+exports.regexify = function (val) {
+  if (!val) return new RegExp(/.^/);
+  if (Array.isArray(val)) val = val.join("|");
+  if (isString(val)) return new RegExp(val);
+  if (isRegExp(val)) return val;
+  throw new TypeError("illegal type for regexify");
+};
+
+exports.arrayify = function (val) {
+  if (!val) return [];
+  if (isString(val)) return exports.list(val);
+  if (Array.isArray(val)) return val;
+  throw new TypeError("illegal type for arrayify");
+};
+
+exports.booleanify = function (val) {
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return val;
+};
+
+var templateVisitor = {
+  enter: function (node, parent, scope, nodes) {
+    if (t.isExpressionStatement(node)) {
+      node = node.expression;
+    }
+    if (t.isIdentifier(node) && has(nodes, node.name)) {
+      this.skip();
+      return nodes[node.name];
+    }
+  }
+};
+
+exports.template = function (name, nodes, keepExpression) {
+  var template = exports.templates[name];
+  if (!template) throw new ReferenceError("unknown template " + name);
+
+  if (nodes === true) {
+    keepExpression = true;
+    nodes = null;
+  }
+
+  template = cloneDeep(template);
+
+  if (!isEmpty(nodes)) {
+    traverse(template, templateVisitor, null, nodes);
+  }
+
+  if (template.body.length > 1) return template.body;
+
+  var node = template.body[0];
+
+  if (!keepExpression && t.isExpressionStatement(node)) {
+    return node.expression;
+  } else {
+    return node;
+  }
+};
+
+exports.parseTemplate = function (loc, code) {
+  var ast = parse({ filename: loc }, code).program;
+  return traverse.removeProperties(ast);
+};
+
+var loadTemplates = function () {
+  var templates = {};
+
+  var templatesLoc = __dirname + "/transformation/templates";
+  if (!fs.existsSync(templatesLoc)) {
+    throw new Error("no templates directory - this is most likely the " +
+                    "result of a broken `npm publish`. Please report to " +
+                    "https://github.com/babel/babel/issues");
+  }
+
+  each(fs.readdirSync(templatesLoc), function (name) {
+    if (name[0] === ".") return;
+
+    var key  = path.basename(name, path.extname(name));
+    var loc  = templatesLoc + "/" + name;
+    var code = fs.readFileSync(loc, "utf8");
+
+    templates[key] = exports.parseTemplate(loc, code);
+  });
+
+  return templates;
+};
+
+try {
+  exports.templates = require("../../templates.json");
+} catch (err) {
+  if (err.code !== "MODULE_NOT_FOUND") throw err;
+
+  exports.templates = loadTemplates();
+}
+
+}).call(this,"/lib/babel")
+},{"../../templates.json":339,"./helpers/parse":25,"./patch":28,"./traversal":114,"./types":119,"debug/node":174,"fs":137,"lodash/collection/contains":196,"lodash/collection/each":197,"lodash/lang/cloneDeep":281,"lodash/lang/isEmpty":285,"lodash/lang/isRegExp":290,"lodash/lang/isString":291,"lodash/object/has":296,"path":146,"util":163}],122:[function(require,module,exports){
+// Acorn is a tiny, fast JavaScript parser written in JavaScript.
+//
+// Acorn was written by Marijn Haverbeke and various contributors and
+// released under an MIT license. The Unicode regexps (for identifiers
+// and whitespace) were taken from [Esprima](http://esprima.org) by
+// Ariya Hidayat.
+//
+// Git repositories for Acorn are available at
+//
+//     http://marijnhaverbeke.nl/git/acorn
+//     https://github.com/marijnh/acorn.git
+//
+// Please use the [github bug tracker][ghbt] to report issues.
+//
+// [ghbt]: https://github.com/marijnh/acorn/issues
+//
+// This file defines the main parser interface. The library also comes
+// with a [error-tolerant parser][dammit] and an
+// [abstract syntax tree walker][walk], defined in other files.
+//
+// [dammit]: acorn_loose.js
+// [walk]: util/walk.js
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports); // CommonJS
+  if (typeof define == "function" && define.amd) return define(["exports"], mod); // AMD
+  mod(root.acorn || (root.acorn = {})); // Plain browser env
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.11.1";
+
+  // The main exported interface (under `self.acorn` when in the
+  // browser) is a `parse` function that takes a code string and
+  // returns an abstract syntax tree as specified by [Mozilla parser
+  // API][api], with the caveat that inline XML is not recognized.
+  //
+  // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+    input = String(inpt); inputLen = input.length;
+    setOptions(opts);
+    initTokenState();
+    var startPos = options.locations ? [tokPos, curPosition()] : tokPos;
+    initParserState();
+    if (options.strictMode) {
+      strict = true;
+    }
+    return parseTopLevel(options.program || startNodeAt(startPos));
+  };
+
+  // A second optional argument can be given to further configure
+  // the parser process. These options are recognized:
+
+  var defaultOptions = exports.defaultOptions = {
+    strictMode: false,
+    playground: false,
+    // `ecmaVersion` indicates the ECMAScript version to parse. Must
+    // be either 3, or 5, or 6. This influences support for strict
+    // mode, the set of reserved words, support for getters and
+    // setters and other features.
+    ecmaVersion: 5,
+    // Turn on `strictSemicolons` to prevent the parser from doing
+    // automatic semicolon insertion.
+    strictSemicolons: false,
+    // When `allowTrailingCommas` is false, the parser will not allow
+    // trailing commas in array and object literals.
+    allowTrailingCommas: true,
+    // By default, reserved words are not enforced. Enable
+    // `forbidReserved` to enforce them. When this option has the
+    // value "everywhere", reserved words and keywords can also not be
+    // used as property names.
+    forbidReserved: false,
+    // When enabled, a return at the top level is not considered an
+    // error.
+    allowReturnOutsideFunction: false,
+    // When enabled, import/export statements are not constrained to
+    // appearing at the top of the program.
+    allowImportExportEverywhere: false,
+    // When enabled, hashbang directive in the beginning of file
+    // is allowed and treated as a line comment.
+    allowHashBang: false,
+    // When `locations` is on, `loc` properties holding objects with
+    // `start` and `end` properties in `{line, column}` form (with
+    // line being 1-based and column 0-based) will be attached to the
+    // nodes.
+    locations: false,
+    // A function can be passed as `onToken` option, which will
+    // cause Acorn to call that function with object in the same
+    // format as tokenize() returns. Note that you are not
+    // allowed to call the parser from the callback—that will
+    // corrupt its internal state.
+    onToken: null,
+    // A function can be passed as `onComment` option, which will
+    // cause Acorn to call that function with `(block, text, start,
+    // end)` parameters whenever a comment is skipped. `block` is a
+    // boolean indicating whether this is a block (`/* */`) comment,
+    // `text` is the content of the comment, and `start` and `end` are
+    // character offsets that denote the start and end of the comment.
+    // When the `locations` option is on, two more parameters are
+    // passed, the full `{line, column}` locations of the start and
+    // end of the comments. Note that you are not allowed to call the
+    // parser from the callback—that will corrupt its internal state.
+    onComment: null,
+    // Nodes have their start and end characters offsets recorded in
+    // `start` and `end` properties (directly on the node, rather than
+    // the `loc` object, which holds line/column data. To also add a
+    // [semi-standardized][range] `range` property holding a `[start,
+    // end]` array with the same numbers, set the `ranges` option to
+    // `true`.
+    //
+    // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
+    ranges: false,
+    // It is possible to parse multiple files into a single AST by
+    // passing the tree produced by parsing the first file as
+    // `program` option in subsequent parses. This will add the
+    // toplevel forms of the parsed file to the `Program` (top) node
+    // of an existing parse tree.
+    program: null,
+    // When `locations` is on, you can pass this to record the source
+    // file in every node's `loc` object.
+    sourceFile: null,
+    // This value, if given, is stored in every node, whether
+    // `locations` is on or off.
+    directSourceFile: null,
+    // When enabled, parenthesized expressions are represented by
+    // (non-standard) ParenthesizedExpression nodes
+    preserveParens: false
+  };
+
+  // This function tries to parse a single expression at a given
+  // offset in a string. Useful for parsing mixed-language formats
+  // that embed JavaScript expressions.
+
+  exports.parseExpressionAt = function(inpt, pos, opts) {
+    input = String(inpt); inputLen = input.length;
+    setOptions(opts);
+    initTokenState(pos);
+    initParserState();
+    return parseExpression();
+  };
+
+  var isArray = function (obj) {
+    return Object.prototype.toString.call(obj) === "[object Array]";
+  };
+
+  function setOptions(opts) {
+    options = {};
+    for (var opt in defaultOptions)
+      options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt];
+    sourceFile = options.sourceFile || null;
+    if (isArray(options.onToken)) {
+      var tokens = options.onToken;
+      options.onToken = function (token) {
+        tokens.push(token);
+      };
+    }
+    if (isArray(options.onComment)) {
+      var comments = options.onComment;
+      options.onComment = function (block, text, start, end, startLoc, endLoc) {
+        var comment = {
+          type: block ? 'Block' : 'Line',
+          value: text,
+          start: start,
+          end: end
+        };
+        if (options.locations) {
+          comment.loc = new SourceLocation();
+          comment.loc.start = startLoc;
+          comment.loc.end = endLoc;
+        }
+        if (options.ranges)
+          comment.range = [start, end];
+        comments.push(comment);
+      };
+    }
+    if (options.ecmaVersion >= 6) {
+      isKeyword = isEcma6Keyword;
+    } else {
+      isKeyword = isEcma5AndLessKeyword;
+    }
+  }
+
+  // The `getLineInfo` function is mostly useful when the
+  // `locations` option is off (for performance reasons) and you
+  // want to find the line/column position for a given character
+  // offset. `input` should be the code string that the offset refers
+  // into.
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+    for (var line = 1, cur = 0;;) {
+      lineBreak.lastIndex = cur;
+      var match = lineBreak.exec(input);
+      if (match && match.index < offset) {
+        ++line;
+        cur = match.index + match[0].length;
+      } else break;
+    }
+    return {line: line, column: offset - cur};
+  };
+
+  function Token() {
+    this.type = tokType;
+    this.value = tokVal;
+    this.start = tokStart;
+    this.end = tokEnd;
+    if (options.locations) {
+      this.loc = new SourceLocation();
+      this.loc.end = tokEndLoc;
+    }
+    if (options.ranges)
+      this.range = [tokStart, tokEnd];
+  }
+
+  exports.Token = Token;
+
+  // Acorn is organized as a tokenizer and a recursive-descent parser.
+  // The `tokenize` export provides an interface to the tokenizer.
+  // Because the tokenizer is optimized for being efficiently used by
+  // the Acorn parser itself, this interface is somewhat crude and not
+  // very modular. Performing another parse or call to `tokenize` will
+  // reset the internal state, and invalidate existing tokenizers.
+
+  exports.tokenize = function(inpt, opts) {
+    input = String(inpt); inputLen = input.length;
+    setOptions(opts);
+    initTokenState();
+    skipSpace();
+
+    function getToken() {
+      lastEnd = tokEnd;
+      readToken();
+      return new Token();
+    }
+    getToken.jumpTo = function(pos, exprAllowed) {
+      tokPos = pos;
+      if (options.locations) {
+        tokCurLine = 1;
+        tokLineStart = lineBreak.lastIndex = 0;
+        var match;
+        while ((match = lineBreak.exec(input)) && match.index < pos) {
+          ++tokCurLine;
+          tokLineStart = match.index + match[0].length;
+        }
+      }
+      tokExprAllowed = !!exprAllowed;
+      skipSpace();
+    };
+    getToken.current = function() { return new Token(); };
+    if (typeof Symbol !== 'undefined') {
+      getToken[Symbol.iterator] = function () {
+        return {
+          next: function () {
+            var token = getToken();
+            return {
+              done: token.type === _eof,
+              value: token
+            };
+          }
+        };
+      };
+    }
+    getToken.options = options;
+    return getToken;
+  };
+
+  // State is kept in (closure-)global variables. We already saw the
+  // `options`, `input`, and `inputLen` variables above.
+
+  // The current position of the tokenizer in the input.
+
+  var tokPos;
+
+  // The start and end offsets of the current token.
+
+  var tokStart, tokEnd;
+
+  // When `options.locations` is true, these hold objects
+  // containing the tokens start and end line/column pairs.
+
+  var tokStartLoc, tokEndLoc;
+
+  // The type and value of the current token. Token types are objects,
+  // named by variables against which they can be compared, and
+  // holding properties that describe them (indicating, for example,
+  // the precedence of an infix operator, and the original name of a
+  // keyword token). The kind of value that's held in `tokVal` depends
+  // on the type of the token. For literals, it is the literal value,
+  // for operators, the operator name, and so on.
+
+  var tokType, tokVal;
+
+  // Internal state for the tokenizer. To distinguish between division
+  // operators and regular expressions, it remembers whether the last
+  // token was one that is allowed to be followed by an expression. In
+  // some cases, notably after ')' or '}' tokens, the situation
+  // depends on the context before the matching opening bracket, so
+  // tokContext keeps a stack of information about current bracketed
+  // forms.
+
+  var tokContext, tokExprAllowed;
+
+  // When `options.locations` is true, these are used to keep
+  // track of the current line, and know when a new line has been
+  // entered.
+
+  var tokCurLine, tokLineStart;
+
+  // These store the position of the previous token, which is useful
+  // when finishing a node and assigning its `end` position.
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  // This is the parser's state. `inFunction` is used to reject
+  // `return` statements outside of functions, `inGenerator` to
+  // reject `yield`s outside of generators, `labels` to verify
+  // that `break` and `continue` have somewhere to jump to, and
+  // `strict` indicates whether strict mode is on.
+
+  var inFunction, inGenerator, inAsync, labels, strict,
+    inXJSChild, inXJSTag, inType;
+
+  function initParserState() {
+    lastStart = lastEnd = tokPos;
+    if (options.locations) lastEndLoc = curPosition();
+    inFunction = inGenerator = inAsync = false;
+    labels = [];
+    skipSpace();
+    readToken();
+  }
+
+  // This function is used to raise exceptions on parse errors. It
+  // takes an offset integer (into the current `input`) to indicate
+  // the location of the error, attaches the position to the end
+  // of the error message, and then raises a `SyntaxError` with that
+  // message.
+
+  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;
+  }
+
+  // Reused empty array added for node fields that are always empty.
+
+  var empty = [];
+
+  // ## Token types
+
+  // The assignment of fine-grained, information-carrying type objects
+  // allows the tokenizer to store the information it has about a
+  // token in a way that is very cheap for the parser to look up.
+
+  // All token type variables start with an underscore, to make them
+  // easy to recognize.
+
+  // These are the general types. The `type` property is only used to
+  // make them recognizeable when debugging.
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+  var _jsxName = {type: "jsxName"};
+
+  // These are JSX-specific token types
+
+  var _xjsName = {type: "xjsName"}, _xjsText = {type: "xjsText"};
+
+  // Keyword tokens. The `keyword` property (also used in keyword-like
+  // operators) indicates that the token originated from an
+  // identifier-like word, which is used when parsing property names.
+  //
+  // The `beforeExpr` property is used to disambiguate between regular
+  // expressions and divisions. It is set on all token types that can
+  // be followed by an expression (thus, a slash after them would be a
+  // regular expression).
+  //
+  // `isLoop` marks a keyword as starting a loop, which is important
+  // to know when parsing a label, in order to allow or disallow
+  // continue jumps to that label.
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _let = {keyword: "let"}, _const = {keyword: "const"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+  var _class = {keyword: "class"}, _extends = {keyword: "extends", beforeExpr: true};
+  var _export = {keyword: "export"}, _import = {keyword: "import"};
+  var _yield = {keyword: "yield", beforeExpr: true};
+
+  // The keywords that denote values.
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  // Some keywords are treated as regular operators. `in` sometimes
+  // (when parsing `for`) needs to be tested against specifically, so
+  // we assign a variable name to it for quick comparing.
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  // Map keyword names to token types.
+
+  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, "let": _let, "const": _const,
+                      "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},
+                      "class": _class, "extends": _extends,
+                      "export": _export, "import": _import, "yield": _yield};
+
+  // Punctuation token types. Again, the `type` property is purely for debugging.
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+  var _arrow = {type: "=>", beforeExpr: true}, _template = {type: "template"};
+  var _ellipsis = {type: "...", beforeExpr: true};
+  var _backQuote = {type: "`"}, _dollarBraceL = {type: "${", beforeExpr: true};
+  var _jsxText = {type: "jsxText"};
+  var _paamayimNekudotayim = { type: "::", beforeExpr: true };
+  var _hash = { type: '#' };
+
+  // Operators. These carry several kinds of properties to help the
+  // parser use them properly (the presence of these properties is
+  // what categorizes them as operators).
+  //
+  // `binop`, when present, specifies that this operator is a binary
+  // operator, and will refer to its precedence.
+  //
+  // `prefix` and `postfix` mark the operator as a prefix or postfix
+  // unary operator. `isUpdate` specifies that the node produced by
+  // the operator should be of type UpdateExpression rather than
+  // simply UnaryExpression (`++` and `--`).
+  //
+  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
+  // binary operators with a very low precedence, that should result
+  // in AssignmentExpression nodes.
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _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 _modulo = {binop: 10, beforeExpr: true};
+
+  // '*' may be multiply or have special meaning in ES6
+  var _star = {binop: 10, beforeExpr: true};
+  var _exponent = {binop: 11, beforeExpr: true, rightAssociative: true};
+
+  // JSX tag boundaries
+  var _jsxTagStart = {type: "jsxTagStart"}, _jsxTagEnd = {type: "jsxTagEnd"};
+
+  // Provide access to the token types for external users of the
+  // tokenizer.
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+                      parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+                      dot: _dot, ellipsis: _ellipsis, question: _question, slash: _slash, eq: _eq,
+                      name: _name, eof: _eof, num: _num, regexp: _regexp, string: _string,
+                      paamayimNekudotayim: _paamayimNekudotayim, exponent: _exponent, hash: _hash,
+                      arrow: _arrow, template: _template, star: _star, assign: _assign,
+                      backQuote: _backQuote, dollarBraceL: _dollarBraceL, jsxName: _jsxName,
+                      jsxText: _jsxText, jsxTagStart: _jsxTagStart, jsxTagEnd: _jsxTagEnd};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  // This is a trick taken from Esprima. It turns out that, on
+  // non-Chrome browsers, to check whether a string is in a set, a
+  // predicate containing a big ugly `switch` statement is faster than
+  // a regular expression, and on Chrome the two are about on par.
+  // This function uses `eval` (non-lexical) to produce such a
+  // predicate from a space-separated string of words.
+  //
+  // It starts by sorting the words by length.
+
+  // Removed to create an eval-free library
+
+  // The ECMAScript 3 reserved word list.
+
+  var isReservedWord3 = function anonymous(str) {
+switch(str.length){case 6:switch(str){case "double":case "export":case "import":case "native":case "public":case "static":case "throws":return true}return false;case 4:switch(str){case "byte":case "char":case "enum":case "goto":case "long":return true}return false;case 5:switch(str){case "class":case "final":case "float":case "short":case "super":return true}return false;case 7:switch(str){case "boolean":case "extends":case "package":case "private":return true}return false;case 9:switch(str){case "interface":case "protected":case "transient":return true}return false;case 8:switch(str){case "abstract":case "volatile":return true}return false;case 10:return str === "implements";case 3:return str === "int";case 12:return str === "synchronized";}
+};
+
+  // ECMAScript 5 reserved words.
+
+  var isReservedWord5 = function anonymous(str) {
+switch(str.length){case 5:switch(str){case "class":case "super":case "const":return true}return false;case 6:switch(str){case "export":case "import":return true}return false;case 4:return str === "enum";case 7:return str === "extends";}
+};
+
+  // The additional reserved words in strict mode.
+
+  var isStrictReservedWord = function anonymous(str) {
+switch(str.length){case 9:switch(str){case "interface":case "protected":return true}return false;case 7:switch(str){case "package":case "private":return true}return false;case 6:switch(str){case "public":case "static":return true}return false;case 10:return str === "implements";case 3:return str === "let";case 5:return str === "yield";}
+};
+
+  // The forbidden variable names in strict mode.
+
+  var isStrictBadIdWord = function anonymous(str) {
+switch(str){case "eval":case "arguments":return true}return false;
+};
+
+  // And the keywords.
+
+  var ecma5AndLessKeywords = "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 isEcma5AndLessKeyword = function anonymous(str) {
+switch(str.length){case 4:switch(str){case "case":case "else":case "with":case "null":case "true":case "void":case "this":return true}return false;case 5:switch(str){case "break":case "catch":case "throw":case "while":case "false":return true}return false;case 3:switch(str){case "for":case "try":case "var":case "new":return true}return false;case 6:switch(str){case "return":case "switch":case "typeof":case "delete":return true}return false;case 8:switch(str){case "continue":case "debugger":case "function":return true}return false;case 2:switch(str){case "do":case "if":case "in":return true}return false;case 7:switch(str){case "default":case "finally":return true}return false;case 10:return str === "instanceof";}
+};
+
+  var ecma6AndLessKeywords = ecma5AndLessKeywords + " let const class extends export import yield";
+
+  var isEcma6Keyword = function anonymous(str) {
+switch(str.length){case 5:switch(str){case "break":case "catch":case "throw":case "while":case "false":case "const":case "class":case "yield":return true}return false;case 4:switch(str){case "case":case "else":case "with":case "null":case "true":case "void":case "this":return true}return false;case 6:switch(str){case "return":case "switch":case "typeof":case "delete":case "export":case "import":return true}return false;case 3:switch(str){case "for":case "try":case "var":case "new":case "let":return true}return false;case 8:switch(str){case "continue":case "debugger":case "function":return true}return false;case 7:switch(str){case "default":case "finally":case "extends":return true}return false;case 2:switch(str){case "do":case "if":case "in":return true}return false;case 10:return str === "instanceof";}
+};
+
+  var isKeyword = isEcma5AndLessKeyword;
+
+  // ## Character categories
+
+  // Big ugly regular expressions that match characters in the
+  // whitespace, identifier, and identifier-start categories. These
+  // are only applied when a character is found to actually have a
+  // code point above 128.
+  // Generated by `tools/generate-identifier-regex.js`.
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
+  var nonASCIIidentifierChars = "\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19B0-\u19C0\u19C8\u19C9\u19D0-\u19D9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F1\uA900-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var decimalNumber = /^\d+$/;
+  var hexNumber = /^[\da-fA-F]+$/;
+
+  // Whether a single character denotes a newline.
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  function isNewLine(code) {
+    return code === 10 || code === 13 || code === 0x2028 || code == 0x2029;
+  }
+
+  // Matches a whole line break (where CRLF is considered a single
+  // line break). Used to count lines.
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  // Test whether a given character code starts an identifier.
+
+  var isIdentifierStart = exports.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 >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  // Test whether a given character is part of an identifier.
+
+  var isIdentifierChar = exports.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 >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  // ## Tokenizer
+
+  // These are used when `options.locations` is on, for the
+  // `tokStartLoc` and `tokEndLoc` properties.
+
+  function Position(line, col) {
+    this.line = line;
+    this.column = col;
+  }
+
+  Position.prototype.offset = function(n) {
+    return new Position(this.line, this.column + n);
+  };
+
+  function curPosition() {
+    return new Position(tokCurLine, tokPos - tokLineStart);
+  }
+
+  // Reset the token state. Used at the start of a parse.
+
+  function initTokenState(pos) {
+    if (pos) {
+      tokPos = pos;
+      tokLineStart = Math.max(0, input.lastIndexOf("\n", pos));
+      tokCurLine = input.slice(0, tokLineStart).split(newline).length;
+    } else {
+      tokCurLine = 1;
+      tokPos = tokLineStart = 0;
+    }
+    tokType = _eof;
+    tokContext = [b_stat];
+    tokExprAllowed = true;
+    inType = strict = false;
+    if (tokPos === 0 && options.allowHashBang && input.slice(0, 2) === '#!') {
+      skipLineComment(2);
+    }
+  }
+
+  // The algorithm used to determine whether a regexp can appear at a
+  // given point in the program is loosely based on sweet.js' approach.
+  // See https://github.com/mozilla/sweet.js/wiki/design
+
+  var b_stat = {token: "{", isExpr: false}, b_expr = {token: "{", isExpr: true}, b_tmpl = {token: "${", isExpr: true};
+  var p_stat = {token: "(", isExpr: false}, p_expr = {token: "(", isExpr: true};
+  var q_tmpl = {token: "`", isExpr: true}, f_expr = {token: "function", isExpr: true};
+  var j_oTag = {token: "<tag", isExpr: false}, j_cTag = {token: "</tag", isExpr: false}, j_expr = {token: "<tag>...</tag>", isExpr: true};
+
+  function curTokContext() {
+    return tokContext[tokContext.length - 1];
+  }
+
+  function braceIsBlock(prevType) {
+    var parent;
+    if (prevType === _colon && (parent = curTokContext()).token == "{")
+      return !parent.isExpr;
+    if (prevType === _return)
+      return newline.test(input.slice(lastEnd, tokStart));
+    if (prevType === _else || prevType === _semi || prevType === _eof)
+      return true;
+    if (prevType == _braceL)
+      return curTokContext() === b_stat;
+    return !tokExprAllowed;
+  }
+
+  // Called at the end of every token. Sets `tokEnd`, `tokVal`, and
+  // maintains `tokContext` and `tokExprAllowed`, and skips the space
+  // after the token, so that the next one's `tokStart` will point at
+  // the right position.
+
+  function finishToken(type, val) {
+    tokEnd = tokPos;
+    if (options.locations) tokEndLoc = curPosition();
+    var prevType = tokType, preserveSpace = false;
+    tokType = type;
+    tokVal = val;
+
+    // Update context info
+    if (type === _parenR || type === _braceR) {
+      var out = tokContext.pop();
+      if (out === b_tmpl) {
+        preserveSpace = tokExprAllowed = true;
+      } else if (out === b_stat && curTokContext() === f_expr) {
+        tokContext.pop();
+        tokExprAllowed = false;
+      } else {
+        tokExprAllowed = !(out && out.isExpr);
+      }
+    } else if (type === _braceL) {
+      switch (curTokContext()) {
+        case j_oTag: tokContext.push(b_expr); break;
+        case j_expr: tokContext.push(b_tmpl); break;
+        default: tokContext.push(braceIsBlock(prevType) ? b_stat : b_expr);
+      }
+      tokExprAllowed = true;
+    } else if (type === _dollarBraceL) {
+      tokContext.push(b_tmpl);
+      tokExprAllowed = true;
+    } else if (type == _parenL) {
+      var statementParens = prevType === _if || prevType === _for || prevType === _with || prevType === _while;
+      tokContext.push(statementParens ? p_stat : p_expr);
+      tokExprAllowed = true;
+    } else if (type == _incDec) {
+      // tokExprAllowed stays unchanged
+    } else if (type.keyword && prevType == _dot) {
+      tokExprAllowed = false;
+    } else if (type == _function) {
+      if (curTokContext() !== b_stat) {
+        tokContext.push(f_expr);
+      }
+      tokExprAllowed = false;
+    } else if (type === _backQuote) {
+      if (curTokContext() === q_tmpl) {
+        tokContext.pop();
+      } else {
+        tokContext.push(q_tmpl);
+        preserveSpace = true;
+      }
+      tokExprAllowed = false;
+    } else if (type === _jsxTagStart) {
+      tokContext.push(j_expr); // treat as beginning of JSX expression
+      tokContext.push(j_oTag); // start opening tag context
+      tokExprAllowed = false;
+    } else if (type === _jsxTagEnd) {
+      var out = tokContext.pop();
+      if (out === j_oTag && prevType === _slash || out === j_cTag) {
+        tokContext.pop();
+        preserveSpace = tokExprAllowed = curTokContext() === j_expr;
+      } else {
+        preserveSpace = tokExprAllowed = true;
+      }
+    } else if (type === _jsxText) {
+      preserveSpace = tokExprAllowed = true;
+    } else if (type === _slash && prevType === _jsxTagStart) {
+      tokContext.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
+      tokContext.push(j_cTag); // reconsider as closing tag context
+      tokExprAllowed = false;
+    } else {
+      tokExprAllowed = type.beforeExpr;
+    }
+
+    if (!preserveSpace) skipSpace();
+  }
+
+  function skipBlockComment() {
+    var startLoc = options.onComment && options.locations && curPosition();
+    var start = tokPos, 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 && curPosition());
+  }
+
+  function skipLineComment(startSkip) {
+    var start = tokPos;
+    var startLoc = options.onComment && options.locations && curPosition();
+    var ch = input.charCodeAt(tokPos+=startSkip);
+    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 + startSkip, tokPos), start, tokPos,
+                        startLoc, options.locations && curPosition());
+  }
+
+  // Called at the start of the parse and after every token. Skips
+  // whitespace and comments, and.
+
+  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(2);
+        } else break;
+      } else if (ch === 160) { // '\xa0'
+        ++tokPos;
+      } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+        ++tokPos;
+      } else {
+        break;
+      }
+    }
+  }
+
+  // ### Token reading
+
+  // This is the function that is called to fetch the next token. It
+  // is somewhat obscure, because it works in character codes rather
+  // than characters, and because operator parsing has been inlined
+  // into it.
+  //
+  // All in the name of speed.
+  //
+  function readToken_dot() {
+    var next = input.charCodeAt(tokPos + 1);
+    if (next >= 48 && next <= 57) return readNumber(true);
+    var next2 = input.charCodeAt(tokPos + 2);
+    if (options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+      tokPos += 3;
+      return finishToken(_ellipsis);
+    } else {
+      ++tokPos;
+      return finishToken(_dot);
+    }
+  }
+
+  function readToken_slash() { // '/'
+    var next = input.charCodeAt(tokPos + 1);
+    if (tokExprAllowed) {++tokPos; return readRegexp();}
+    if (next === 61) return finishOp(_assign, 2);
+    return finishOp(_slash, 1);
+  }
+
+  function readToken_modulo() { // '%'
+    var next = input.charCodeAt(tokPos + 1);
+    if (next === 61) return finishOp(_assign, 2);
+    return finishOp(_modulo, 1);
+  }
+
+  function readToken_mult() { // '*'
+    var type = _star;
+    var width = 1;
+    var next = input.charCodeAt(tokPos + 1);
+
+    if (options.ecmaVersion >= 7 && next === 42) { // '*'
+      width++;
+      next = input.charCodeAt(tokPos + 2);
+      type = _exponent;
+    }
+
+    if (next === 61) { // '='
+      width++;
+      type = _assign;
+    }
+    
+    return finishOp(type, width);
+  }
+
+  function readToken_pipe_amp(code) { // '|&'
+    var next = input.charCodeAt(tokPos + 1);
+    if (next === code) {
+      if (options.playground && input.charCodeAt(tokPos + 2) === 61) return finishOp(_assign, 3);
+      return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+    }
+    if (next === 61) return finishOp(_assign, 2);
+    return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() { // '^'
+    var next = input.charCodeAt(tokPos + 1);
+    if (next === 61) return finishOp(_assign, 2);
+    return 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))) {
+        // A `-->` line comment
+        skipLineComment(3);
+        skipSpace();
+        return readToken();
+      }
+      return finishOp(_incDec, 2);
+    }
+    if (next === 61) return finishOp(_assign, 2);
+    return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) { // '<>'
+    var next = input.charCodeAt(tokPos + 1);
+    var size = 1;
+    if (!inType && next === code) {
+      size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+      if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+      return finishOp(_bitShift, size);
+    }
+    if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+        input.charCodeAt(tokPos + 3) == 45) {
+      // `<!--`, an XML-style comment that should be interpreted as a line comment
+      skipLineComment(4);
+      skipSpace();
+      return readToken();
+    }
+    if (!inType) {
+      if (tokExprAllowed && code === 60) {
+        ++tokPos;
+        return finishToken(_jsxTagStart);
+      }
+      if (code === 62) {
+        var context = curTokContext();
+        if (context === j_oTag || context === j_cTag) {
+          ++tokPos;
+          return finishToken(_jsxTagEnd);
+        }
+      }
+    }
+    if (next === 61)
+      size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+    return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) { // '=!', '=>'
+    var next = input.charCodeAt(tokPos + 1);
+    if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+    if (code === 61 && next === 62 && options.ecmaVersion >= 6) { // '=>'
+      tokPos += 2;
+      return finishToken(_arrow);
+    }
+    return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  // Get token inside ES6 template (special rules work there).
+
+  function getTemplateToken(code) {
+    // '`' and '${' have special meanings, but they should follow
+    // string (can be empty)
+    if (tokType === _string) {
+      if (code === 96) { // '`'
+        ++tokPos;
+        return finishToken(_bquote);
+      } else if (code === 36 && input.charCodeAt(tokPos + 1) === 123) { // '${'
+        tokPos += 2;
+        return finishToken(_dollarBraceL);
+      }
+    }
+    // anything else is considered string literal
+    return readTmplString();
+  }
+
+  function getTokenFromCode(code) {
+    switch(code) {
+      // The interpretation of a dot depends on whether it is followed
+      // by a digit or another two dots.
+    case 46: // '.'
+      return readToken_dot();
+
+      // Punctuation tokens.
+    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 63: ++tokPos; return finishToken(_question);
+
+    case 35:
+      if (options.playground) {
+        ++tokPos;
+        return finishToken(_hash);
+      }
+
+    case 58:
+      ++tokPos;
+      if (options.ecmaVersion >= 7) {
+        var next = input.charCodeAt(tokPos);
+        if (next === 58) {
+          ++tokPos;
+          return finishToken(_paamayimNekudotayim);
+        }
+      }
+      return finishToken(_colon);
+
+    case 96: // '`'
+      if (options.ecmaVersion >= 6) {
+        ++tokPos;
+        return finishToken(_backQuote);
+      } else {
+        return false;
+      }
+
+    case 48: // '0'
+      var next = input.charCodeAt(tokPos + 1);
+      if (next === 120 || next === 88) return readRadixNumber(16); // '0x', '0X' - hex number
+      if (options.ecmaVersion >= 6) {
+        if (next === 111 || next === 79) return readRadixNumber(8); // '0o', '0O' - octal number
+        if (next === 98 || next === 66) return readRadixNumber(2); // '0b', '0B' - binary number
+      }
+      // Anything else beginning with a digit is an integer, octal
+      // number, or float.
+    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
+      return readNumber(false);
+
+      // Quotes produce strings.
+    case 34: case 39: // '"', "'"
+      return inXJSTag ? readXJSStringLiteral() : readString(code);
+
+    // Operators are parsed inline in tiny state machines. '=' (61) is
+    // often referred to. `finishOp` simply skips the amount of
+    // characters it is given as second argument, and returns a token
+    // of the type given by its first argument.
+
+    case 47: // '/'
+      return readToken_slash();
+
+    case 37: // '%'
+      return readToken_modulo();
+
+    case 42: // '*'
+      return readToken_mult();
+
+    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() {
+    tokStart = tokPos;
+    if (options.locations) tokStartLoc = curPosition();
+    if (tokPos >= inputLen) return finishToken(_eof);
+
+    var context = curTokContext();
+
+    if (context === q_tmpl) {
+      return readTmplToken();
+    }
+
+    if (context === j_expr) {
+      return readJSXToken();
+    }
+
+    var code = input.charCodeAt(tokPos);
+    if (context === j_oTag || context === j_cTag) {
+      // JSX identifier
+      if (isIdentifierStart(code)) return readJSXWord();
+    } else if (context === j_expr) {
+      return readJSXToken();
+    } else {
+      // Identifier or keyword. '\uXXXX' sequences are allowed in
+      // identifiers, so '\' also dispatches to that.
+      if (isIdentifierStart(code) || code === 92 /* '\' */) return readWord();
+    }
+
+    var tok = getTokenFromCode(code);
+
+    if (tok === false) {
+      // If we are here, we either found a non-ASCII identifier
+      // character, or something that's entirely disallowed.
+      var ch = String.fromCharCode(code);
+      if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+      raise(tokPos, "Unexpected character '" + ch + "'");
+    }
+    return tok;
+  }
+
+  function finishOp(type, size, shouldSkipSpace) {
+    var str = input.slice(tokPos, tokPos + size);
+    tokPos += size;
+    finishToken(type, str, shouldSkipSpace);
+  }
+
+  var regexpUnicodeSupport = false;
+  try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
+  catch(e) {}
+
+  // Parse a regular expression. Some context-awareness is necessary,
+  // since a '/' inside a '[]' set does not end the expression.
+
+  function readRegexp() {
+    var content = "", escaped, inClass, start = tokPos;
+    for (;;) {
+      if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+      var ch = nextChar();
+      if (newline.test(ch)) raise(start, "Unterminated regular expression");
+      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;
+    // Need to use `readWord1` because '\uXXXX' sequences are allowed
+    // here (don't ask).
+    var mods = readWord1();
+    // Detect invalid regular expressions.
+    var tmp = content;
+    if (mods) {
+      var validFlags = /^[gmsiy]*$/;
+      if (options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
+      if (!validFlags.test(mods)) raise(start, "Invalid regular expression flag");
+      if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
+        // Replace each astral symbol and every Unicode code point
+        // escape sequence that represents such a symbol with a single
+        // ASCII symbol to avoid throwing on regular expressions that
+        // are only valid in combination with the `/u` flag.
+        tmp = tmp
+          .replace(/\\u\{([0-9a-fA-F]{5,6})\}/g, "x")
+          .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
+      }
+    }
+    // Detect invalid regular expressions.
+    try {
+      new RegExp(tmp);
+    } catch (e) {
+      if (e instanceof SyntaxError) raise(start, "Error parsing regular expression: " + e.message);
+      raise(e);
+    }
+    // Get a regular expression object for this pattern-flag pair, or `null` in
+    // case the current environment doesn't support the flags it uses.
+    try {
+      var value = new RegExp(content, mods);
+    } catch (err) {
+      value = null;
+  }
+    return finishToken(_regexp, {pattern: content, flags: mods, value: value});
+  }
+
+  // Read an integer in the given radix. Return null if zero digits
+  // were read, the integer value otherwise. When `len` is given, this
+  // will return `null` unless the integer has exactly `len` digits.
+
+  function readInt(radix, len) {
+    var start = tokPos, total = 0;
+    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+      var code = input.charCodeAt(tokPos), val;
+      if (code >= 97) val = code - 97 + 10; // a
+      else if (code >= 65) val = code - 65 + 10; // A
+      else if (code >= 48 && code <= 57) val = code - 48; // 0-9
+      else val = Infinity;
+      if (val >= radix) break;
+      ++tokPos;
+      total = total * radix + val;
+    }
+    if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+    return total;
+  }
+
+  function readRadixNumber(radix) {
+    tokPos += 2; // 0x
+    var val = readInt(radix);
+    if (val == null) raise(tokStart + 2, "Expected number in radix " + radix);
+    if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+    return finishToken(_num, val);
+  }
+
+  // Read an integer, octal integer, or floating-point number.
+
+  function readNumber(startsWithDot) {
+    var start = tokPos, isFloat = false, 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) { // 'eE'
+      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), 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);
+    return finishToken(_num, val);
+  }
+
+  // Read a string value, interpreting backslash-escapes.
+
+  function readCodePoint() {
+    var ch = input.charCodeAt(tokPos), code;
+    
+    if (ch === 123) {
+      if (options.ecmaVersion < 6) unexpected();
+      ++tokPos;
+      code = readHexChar(input.indexOf('}', tokPos) - tokPos);
+      ++tokPos;
+      if (code > 0x10FFFF) unexpected();
+    } else {
+      code = readHexChar(4);
+    }
+
+    // UTF-16 Encoding
+    if (code <= 0xFFFF) {
+      return String.fromCharCode(code);
+    }
+    var cu1 = ((code - 0x10000) >> 10) + 0xD800;
+    var cu2 = ((code - 0x10000) & 1023) + 0xDC00;
+    return String.fromCharCode(cu1, cu2);
+  }
+
+  function readString(quote) {
+    var isJSX = curTokContext() === j_oTag;
+    var out = "", chunkStart = ++tokPos;
+    for (;;) {
+      if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+      var ch = input.charCodeAt(tokPos);
+      if (ch === quote) break;
+      if (ch === 92 && !isJSX) { // '\'
+        out += input.slice(chunkStart, tokPos);
+        out += readEscapedChar();
+        chunkStart = tokPos;
+      } else if (ch === 38 && isJSX) { // '&'
+        out += input.slice(chunkStart, tokPos);
+        out += readJSXEntity();
+        chunkStart = tokPos;
+      } else {
+        if (isNewLine(ch) && !isJSX) raise(tokStart, "Unterminated string constant");
+        ++tokPos;
+      }
+    }
+    out += input.slice(chunkStart, tokPos++);
+    return finishToken(_string, out);
+  }
+
+  // Reads template string tokens.
+
+  function readTmplToken() {
+    var out = "", chunkStart = tokPos;
+    for (;;) {
+      if (tokPos >= inputLen) raise(tokStart, "Unterminated template");
+      var ch = input.charCodeAt(tokPos);
+      if (ch === 96 || ch === 36 && input.charCodeAt(tokPos + 1) === 123) { // '`', '${'
+        if (tokPos === tokStart && tokType === _template) {
+          if (ch === 36) {
+            tokPos += 2;
+            return finishToken(_dollarBraceL);
+          } else {
+            ++tokPos;
+            return finishToken(_backQuote);
+          }
+        }
+        out += input.slice(chunkStart, tokPos);
+        return finishToken(_template, out);
+      }
+      if (ch === 92) { // '\'
+        out += input.slice(chunkStart, tokPos);
+        out += readEscapedChar();
+        chunkStart = tokPos;
+      } else if (isNewLine(ch)) {
+        out += input.slice(chunkStart, tokPos);
+        ++tokPos;
+        if (ch === 13 && input.charCodeAt(tokPos) === 10) {
+          ++tokPos;
+          out += "\n";
+        } else {
+          out += String.fromCharCode(ch);
+        }
+        if (options.locations) {
+          ++tokCurLine;
+          tokLineStart = tokPos;
+        }
+        chunkStart = tokPos;
+      } else {
+        ++tokPos;
+      }
+    }
+  }
+
+  var XHTMLEntities = {
+    quot: '\u0022',
+    amp: '&',
+    apos: '\u0027',
+    lt: '<',
+    gt: '>',
+    nbsp: '\u00A0',
+    iexcl: '\u00A1',
+    cent: '\u00A2',
+    pound: '\u00A3',
+    curren: '\u00A4',
+    yen: '\u00A5',
+    brvbar: '\u00A6',
+    sect: '\u00A7',
+    uml: '\u00A8',
+    copy: '\u00A9',
+    ordf: '\u00AA',
+    laquo: '\u00AB',
+    not: '\u00AC',
+    shy: '\u00AD',
+    reg: '\u00AE',
+    macr: '\u00AF',
+    deg: '\u00B0',
+    plusmn: '\u00B1',
+    sup2: '\u00B2',
+    sup3: '\u00B3',
+    acute: '\u00B4',
+    micro: '\u00B5',
+    para: '\u00B6',
+    middot: '\u00B7',
+    cedil: '\u00B8',
+    sup1: '\u00B9',
+    ordm: '\u00BA',
+    raquo: '\u00BB',
+    frac14: '\u00BC',
+    frac12: '\u00BD',
+    frac34: '\u00BE',
+    iquest: '\u00BF',
+    Agrave: '\u00C0',
+    Aacute: '\u00C1',
+    Acirc: '\u00C2',
+    Atilde: '\u00C3',
+    Auml: '\u00C4',
+    Aring: '\u00C5',
+    AElig: '\u00C6',
+    Ccedil: '\u00C7',
+    Egrave: '\u00C8',
+    Eacute: '\u00C9',
+    Ecirc: '\u00CA',
+    Euml: '\u00CB',
+    Igrave: '\u00CC',
+    Iacute: '\u00CD',
+    Icirc: '\u00CE',
+    Iuml: '\u00CF',
+    ETH: '\u00D0',
+    Ntilde: '\u00D1',
+    Ograve: '\u00D2',
+    Oacute: '\u00D3',
+    Ocirc: '\u00D4',
+    Otilde: '\u00D5',
+    Ouml: '\u00D6',
+    times: '\u00D7',
+    Oslash: '\u00D8',
+    Ugrave: '\u00D9',
+    Uacute: '\u00DA',
+    Ucirc: '\u00DB',
+    Uuml: '\u00DC',
+    Yacute: '\u00DD',
+    THORN: '\u00DE',
+    szlig: '\u00DF',
+    agrave: '\u00E0',
+    aacute: '\u00E1',
+    acirc: '\u00E2',
+    atilde: '\u00E3',
+    auml: '\u00E4',
+    aring: '\u00E5',
+    aelig: '\u00E6',
+    ccedil: '\u00E7',
+    egrave: '\u00E8',
+    eacute: '\u00E9',
+    ecirc: '\u00EA',
+    euml: '\u00EB',
+    igrave: '\u00EC',
+    iacute: '\u00ED',
+    icirc: '\u00EE',
+    iuml: '\u00EF',
+    eth: '\u00F0',
+    ntilde: '\u00F1',
+    ograve: '\u00F2',
+    oacute: '\u00F3',
+    ocirc: '\u00F4',
+    otilde: '\u00F5',
+    ouml: '\u00F6',
+    divide: '\u00F7',
+    oslash: '\u00F8',
+    ugrave: '\u00F9',
+    uacute: '\u00FA',
+    ucirc: '\u00FB',
+    uuml: '\u00FC',
+    yacute: '\u00FD',
+    thorn: '\u00FE',
+    yuml: '\u00FF',
+    OElig: '\u0152',
+    oelig: '\u0153',
+    Scaron: '\u0160',
+    scaron: '\u0161',
+    Yuml: '\u0178',
+    fnof: '\u0192',
+    circ: '\u02C6',
+    tilde: '\u02DC',
+    Alpha: '\u0391',
+    Beta: '\u0392',
+    Gamma: '\u0393',
+    Delta: '\u0394',
+    Epsilon: '\u0395',
+    Zeta: '\u0396',
+    Eta: '\u0397',
+    Theta: '\u0398',
+    Iota: '\u0399',
+    Kappa: '\u039A',
+    Lambda: '\u039B',
+    Mu: '\u039C',
+    Nu: '\u039D',
+    Xi: '\u039E',
+    Omicron: '\u039F',
+    Pi: '\u03A0',
+    Rho: '\u03A1',
+    Sigma: '\u03A3',
+    Tau: '\u03A4',
+    Upsilon: '\u03A5',
+    Phi: '\u03A6',
+    Chi: '\u03A7',
+    Psi: '\u03A8',
+    Omega: '\u03A9',
+    alpha: '\u03B1',
+    beta: '\u03B2',
+    gamma: '\u03B3',
+    delta: '\u03B4',
+    epsilon: '\u03B5',
+    zeta: '\u03B6',
+    eta: '\u03B7',
+    theta: '\u03B8',
+    iota: '\u03B9',
+    kappa: '\u03BA',
+    lambda: '\u03BB',
+    mu: '\u03BC',
+    nu: '\u03BD',
+    xi: '\u03BE',
+    omicron: '\u03BF',
+    pi: '\u03C0',
+    rho: '\u03C1',
+    sigmaf: '\u03C2',
+    sigma: '\u03C3',
+    tau: '\u03C4',
+    upsilon: '\u03C5',
+    phi: '\u03C6',
+    chi: '\u03C7',
+    psi: '\u03C8',
+    omega: '\u03C9',
+    thetasym: '\u03D1',
+    upsih: '\u03D2',
+    piv: '\u03D6',
+    ensp: '\u2002',
+    emsp: '\u2003',
+    thinsp: '\u2009',
+    zwnj: '\u200C',
+    zwj: '\u200D',
+    lrm: '\u200E',
+    rlm: '\u200F',
+    ndash: '\u2013',
+    mdash: '\u2014',
+    lsquo: '\u2018',
+    rsquo: '\u2019',
+    sbquo: '\u201A',
+    ldquo: '\u201C',
+    rdquo: '\u201D',
+    bdquo: '\u201E',
+    dagger: '\u2020',
+    Dagger: '\u2021',
+    bull: '\u2022',
+    hellip: '\u2026',
+    permil: '\u2030',
+    prime: '\u2032',
+    Prime: '\u2033',
+    lsaquo: '\u2039',
+    rsaquo: '\u203A',
+    oline: '\u203E',
+    frasl: '\u2044',
+    euro: '\u20AC',
+    image: '\u2111',
+    weierp: '\u2118',
+    real: '\u211C',
+    trade: '\u2122',
+    alefsym: '\u2135',
+    larr: '\u2190',
+    uarr: '\u2191',
+    rarr: '\u2192',
+    darr: '\u2193',
+    harr: '\u2194',
+    crarr: '\u21B5',
+    lArr: '\u21D0',
+    uArr: '\u21D1',
+    rArr: '\u21D2',
+    dArr: '\u21D3',
+    hArr: '\u21D4',
+    forall: '\u2200',
+    part: '\u2202',
+    exist: '\u2203',
+    empty: '\u2205',
+    nabla: '\u2207',
+    isin: '\u2208',
+    notin: '\u2209',
+    ni: '\u220B',
+    prod: '\u220F',
+    sum: '\u2211',
+    minus: '\u2212',
+    lowast: '\u2217',
+    radic: '\u221A',
+    prop: '\u221D',
+    infin: '\u221E',
+    ang: '\u2220',
+    and: '\u2227',
+    or: '\u2228',
+    cap: '\u2229',
+    cup: '\u222A',
+    'int': '\u222B',
+    there4: '\u2234',
+    sim: '\u223C',
+    cong: '\u2245',
+    asymp: '\u2248',
+    ne: '\u2260',
+    equiv: '\u2261',
+    le: '\u2264',
+    ge: '\u2265',
+    sub: '\u2282',
+    sup: '\u2283',
+    nsub: '\u2284',
+    sube: '\u2286',
+    supe: '\u2287',
+    oplus: '\u2295',
+    otimes: '\u2297',
+    perp: '\u22A5',
+    sdot: '\u22C5',
+    lceil: '\u2308',
+    rceil: '\u2309',
+    lfloor: '\u230A',
+    rfloor: '\u230B',
+    lang: '\u2329',
+    rang: '\u232A',
+    loz: '\u25CA',
+    spades: '\u2660',
+    clubs: '\u2663',
+    hearts: '\u2665',
+    diams: '\u2666'
+  };
+
+  function readJSXEntity() {
+    var str = '', count = 0, entity;
+    var ch = input[tokPos];
+    if (ch !== '&') raise(tokPos, "Entity must start with an ampersand");
+    var startPos = ++tokPos;
+    while (tokPos < inputLen && count++ < 10) {
+      ch = input[tokPos++];
+      if (ch === ';') {
+        if (str[0] === '#') {
+          if (str[1] === 'x') {
+            str = str.substr(2);
+            if (hexNumber.test(str)) {
+              entity = String.fromCharCode(parseInt(str, 16));
+            }
+          } else {
+            str = str.substr(1);
+            if (decimalNumber.test(str)) {
+              entity = String.fromCharCode(parseInt(str, 10));
+            }
+          }
+        } else {
+          entity = XHTMLEntities[str];
+        }
+        break;
+      }
+      str += ch;
+    }
+    if (!entity) {
+      tokPos = startPos;
+      return '&';
+    }
+    return entity;
+  }
+
+  // Reads inline JSX contents token.
+
+  function readJSXToken() {
+    var out = "", chunkStart = tokPos;
+    for (;;) {
+      if (tokPos >= inputLen) raise(tokStart, "Unterminated JSX contents");
+      var ch = input.charCodeAt(tokPos);
+      switch (ch) {
+        case 123: // '{'
+        case 60: // '<'
+          if (tokPos === tokStart) {
+            return getTokenFromCode(ch);
+          }
+          out += input.slice(chunkStart, tokPos);
+          return finishToken(_jsxText, out);
+
+        case 38: // '&'
+          out += input.slice(chunkStart, tokPos);
+          out += readJSXEntity();
+          chunkStart = tokPos;
+          break;
+
+        default:
+          if (isNewLine(ch)) {
+            out += input.slice(chunkStart, tokPos);
+            ++tokPos;
+            if (ch === 13 && input.charCodeAt(tokPos) === 10) {
+              ++tokPos;
+              out += "\n";
+            } else {
+              out += String.fromCharCode(ch);
+            }
+            if (options.locations) {
+              ++tokCurLine;
+              tokLineStart = tokPos;
+            }
+            chunkStart = tokPos;
+          } else {
+            ++tokPos;
+          }
+      }
+    }
+  }
+
+  // Used to read escaped characters
+
+  function readEscapedChar() {
+    var 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");
+      tokPos += octal.length - 1;
+      return String.fromCharCode(parseInt(octal, 8));
+    } else {
+      switch (ch) {
+        case 110: return "\n"; // 'n' -> '\n'
+        case 114: return "\r"; // 'r' -> '\r'
+        case 120: return String.fromCharCode(readHexChar(2)); // 'x'
+        case 117: return readCodePoint(); // 'u'
+        case 116: return "\t"; // 't' -> '\t'
+        case 98: return "\b"; // 'b' -> '\b'
+        case 118: return "\u000b"; // 'v' -> '\u000b'
+        case 102: return "\f"; // 'f' -> '\f'
+        case 48: return "\0"; // 0 -> '\0'
+        case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos; // '\r\n'
+        case 10: // ' \n'
+          if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+          return "";
+        default: return String.fromCharCode(ch);
+      }
+    }
+  }
+
+  var XHTMLEntities = {
+    quot: '\u0022',
+    amp: '&',
+    apos: '\u0027',
+    lt: '<',
+    gt: '>',
+    nbsp: '\u00A0',
+    iexcl: '\u00A1',
+    cent: '\u00A2',
+    pound: '\u00A3',
+    curren: '\u00A4',
+    yen: '\u00A5',
+    brvbar: '\u00A6',
+    sect: '\u00A7',
+    uml: '\u00A8',
+    copy: '\u00A9',
+    ordf: '\u00AA',
+    laquo: '\u00AB',
+    not: '\u00AC',
+    shy: '\u00AD',
+    reg: '\u00AE',
+    macr: '\u00AF',
+    deg: '\u00B0',
+    plusmn: '\u00B1',
+    sup2: '\u00B2',
+    sup3: '\u00B3',
+    acute: '\u00B4',
+    micro: '\u00B5',
+    para: '\u00B6',
+    middot: '\u00B7',
+    cedil: '\u00B8',
+    sup1: '\u00B9',
+    ordm: '\u00BA',
+    raquo: '\u00BB',
+    frac14: '\u00BC',
+    frac12: '\u00BD',
+    frac34: '\u00BE',
+    iquest: '\u00BF',
+    Agrave: '\u00C0',
+    Aacute: '\u00C1',
+    Acirc: '\u00C2',
+    Atilde: '\u00C3',
+    Auml: '\u00C4',
+    Aring: '\u00C5',
+    AElig: '\u00C6',
+    Ccedil: '\u00C7',
+    Egrave: '\u00C8',
+    Eacute: '\u00C9',
+    Ecirc: '\u00CA',
+    Euml: '\u00CB',
+    Igrave: '\u00CC',
+    Iacute: '\u00CD',
+    Icirc: '\u00CE',
+    Iuml: '\u00CF',
+    ETH: '\u00D0',
+    Ntilde: '\u00D1',
+    Ograve: '\u00D2',
+    Oacute: '\u00D3',
+    Ocirc: '\u00D4',
+    Otilde: '\u00D5',
+    Ouml: '\u00D6',
+    times: '\u00D7',
+    Oslash: '\u00D8',
+    Ugrave: '\u00D9',
+    Uacute: '\u00DA',
+    Ucirc: '\u00DB',
+    Uuml: '\u00DC',
+    Yacute: '\u00DD',
+    THORN: '\u00DE',
+    szlig: '\u00DF',
+    agrave: '\u00E0',
+    aacute: '\u00E1',
+    acirc: '\u00E2',
+    atilde: '\u00E3',
+    auml: '\u00E4',
+    aring: '\u00E5',
+    aelig: '\u00E6',
+    ccedil: '\u00E7',
+    egrave: '\u00E8',
+    eacute: '\u00E9',
+    ecirc: '\u00EA',
+    euml: '\u00EB',
+    igrave: '\u00EC',
+    iacute: '\u00ED',
+    icirc: '\u00EE',
+    iuml: '\u00EF',
+    eth: '\u00F0',
+    ntilde: '\u00F1',
+    ograve: '\u00F2',
+    oacute: '\u00F3',
+    ocirc: '\u00F4',
+    otilde: '\u00F5',
+    ouml: '\u00F6',
+    divide: '\u00F7',
+    oslash: '\u00F8',
+    ugrave: '\u00F9',
+    uacute: '\u00FA',
+    ucirc: '\u00FB',
+    uuml: '\u00FC',
+    yacute: '\u00FD',
+    thorn: '\u00FE',
+    yuml: '\u00FF',
+    OElig: '\u0152',
+    oelig: '\u0153',
+    Scaron: '\u0160',
+    scaron: '\u0161',
+    Yuml: '\u0178',
+    fnof: '\u0192',
+    circ: '\u02C6',
+    tilde: '\u02DC',
+    Alpha: '\u0391',
+    Beta: '\u0392',
+    Gamma: '\u0393',
+    Delta: '\u0394',
+    Epsilon: '\u0395',
+    Zeta: '\u0396',
+    Eta: '\u0397',
+    Theta: '\u0398',
+    Iota: '\u0399',
+    Kappa: '\u039A',
+    Lambda: '\u039B',
+    Mu: '\u039C',
+    Nu: '\u039D',
+    Xi: '\u039E',
+    Omicron: '\u039F',
+    Pi: '\u03A0',
+    Rho: '\u03A1',
+    Sigma: '\u03A3',
+    Tau: '\u03A4',
+    Upsilon: '\u03A5',
+    Phi: '\u03A6',
+    Chi: '\u03A7',
+    Psi: '\u03A8',
+    Omega: '\u03A9',
+    alpha: '\u03B1',
+    beta: '\u03B2',
+    gamma: '\u03B3',
+    delta: '\u03B4',
+    epsilon: '\u03B5',
+    zeta: '\u03B6',
+    eta: '\u03B7',
+    theta: '\u03B8',
+    iota: '\u03B9',
+    kappa: '\u03BA',
+    lambda: '\u03BB',
+    mu: '\u03BC',
+    nu: '\u03BD',
+    xi: '\u03BE',
+    omicron: '\u03BF',
+    pi: '\u03C0',
+    rho: '\u03C1',
+    sigmaf: '\u03C2',
+    sigma: '\u03C3',
+    tau: '\u03C4',
+    upsilon: '\u03C5',
+    phi: '\u03C6',
+    chi: '\u03C7',
+    psi: '\u03C8',
+    omega: '\u03C9',
+    thetasym: '\u03D1',
+    upsih: '\u03D2',
+    piv: '\u03D6',
+    ensp: '\u2002',
+    emsp: '\u2003',
+    thinsp: '\u2009',
+    zwnj: '\u200C',
+    zwj: '\u200D',
+    lrm: '\u200E',
+    rlm: '\u200F',
+    ndash: '\u2013',
+    mdash: '\u2014',
+    lsquo: '\u2018',
+    rsquo: '\u2019',
+    sbquo: '\u201A',
+    ldquo: '\u201C',
+    rdquo: '\u201D',
+    bdquo: '\u201E',
+    dagger: '\u2020',
+    Dagger: '\u2021',
+    bull: '\u2022',
+    hellip: '\u2026',
+    permil: '\u2030',
+    prime: '\u2032',
+    Prime: '\u2033',
+    lsaquo: '\u2039',
+    rsaquo: '\u203A',
+    oline: '\u203E',
+    frasl: '\u2044',
+    euro: '\u20AC',
+    image: '\u2111',
+    weierp: '\u2118',
+    real: '\u211C',
+    trade: '\u2122',
+    alefsym: '\u2135',
+    larr: '\u2190',
+    uarr: '\u2191',
+    rarr: '\u2192',
+    darr: '\u2193',
+    harr: '\u2194',
+    crarr: '\u21B5',
+    lArr: '\u21D0',
+    uArr: '\u21D1',
+    rArr: '\u21D2',
+    dArr: '\u21D3',
+    hArr: '\u21D4',
+    forall: '\u2200',
+    part: '\u2202',
+    exist: '\u2203',
+    empty: '\u2205',
+    nabla: '\u2207',
+    isin: '\u2208',
+    notin: '\u2209',
+    ni: '\u220B',
+    prod: '\u220F',
+    sum: '\u2211',
+    minus: '\u2212',
+    lowast: '\u2217',
+    radic: '\u221A',
+    prop: '\u221D',
+    infin: '\u221E',
+    ang: '\u2220',
+    and: '\u2227',
+    or: '\u2228',
+    cap: '\u2229',
+    cup: '\u222A',
+    'int': '\u222B',
+    there4: '\u2234',
+    sim: '\u223C',
+    cong: '\u2245',
+    asymp: '\u2248',
+    ne: '\u2260',
+    equiv: '\u2261',
+    le: '\u2264',
+    ge: '\u2265',
+    sub: '\u2282',
+    sup: '\u2283',
+    nsub: '\u2284',
+    sube: '\u2286',
+    supe: '\u2287',
+    oplus: '\u2295',
+    otimes: '\u2297',
+    perp: '\u22A5',
+    sdot: '\u22C5',
+    lceil: '\u2308',
+    rceil: '\u2309',
+    lfloor: '\u230A',
+    rfloor: '\u230B',
+    lang: '\u2329',
+    rang: '\u232A',
+    loz: '\u25CA',
+    spades: '\u2660',
+    clubs: '\u2663',
+    hearts: '\u2665',
+    diams: '\u2666'
+  };
+
+  function readXJSEntity() {
+    var str = '', count = 0, entity;
+    var ch = nextChar();
+    if (ch !== '&') raise(tokPos, "Entity must start with an ampersand");
+    var startPos = ++tokPos;
+    while (tokPos < inputLen && count++ < 10) {
+      ch = nextChar();
+      tokPos++;
+      if (ch === ';') {
+        if (str[0] === '#') {
+          if (str[1] === 'x') {
+            str = str.substr(2);
+            if (hexNumber.test(str)) {
+              entity = String.fromCharCode(parseInt(str, 16));
+            }
+          } else {
+            str = str.substr(1);
+            if (decimalNumber.test(str)) {
+              entity = String.fromCharCode(parseInt(str, 10));
+            }
+          }
+        } else {
+          entity = XHTMLEntities[str];
+        }
+        break;
+      }
+      str += ch;
+    }
+    if (!entity) {
+      tokPos = startPos;
+      return '&';
+    }
+    return entity;
+  }
+
+  function readXJSText(stopChars) {
+    var str = '';
+    while (tokPos < inputLen) {
+      var ch = nextChar();
+      if (stopChars.indexOf(ch) !== -1) {
+        break;
+      }
+      if (ch === '&') {
+        str += readXJSEntity();
+      } else {
+        ++tokPos;
+        if (ch === '\r' && nextChar() === '\n') {
+          str += ch;
+          ++tokPos;
+          ch = '\n';
+        }
+        if (ch === '\n' && options.locations) {
+          tokLineStart = tokPos;
+          ++tokCurLine;
+        }
+        str += ch;
+      }
+    }
+    return finishToken(_xjsText, str);
+  }
+
+  function readXJSStringLiteral() {
+    var quote = input.charCodeAt(tokPos);
+
+    if (quote !== 34 && quote !== 39) {
+      raise("String literal must starts with a quote");
+    }
+
+    ++tokPos;
+
+    readXJSText([String.fromCharCode(quote)]);
+
+    if (quote !== input.charCodeAt(tokPos)) {
+      unexpected();
+    }
+
+    ++tokPos;
+
+    return finishToken(tokType, tokVal);
+  }
+
+  // Used to read character escape sequences ('\x', '\u', '\U').
+
+  function readHexChar(len) {
+    var n = readInt(16, len);
+    if (n === null) raise(tokStart, "Bad character escape sequence");
+    return n;
+  }
+
+  // Used to signal to callers of `readWord1` whether the word
+  // contained any escape sequences. This is needed because words with
+  // escape sequences must not be interpreted as keywords.
+
+  var containsEsc;
+
+  // Read an identifier, and return it as a string. Sets `containsEsc`
+  // to whether the word contained a '\u' escape.
+  //
+  // Incrementally adds only escaped chars, adding other chunks as-is
+  // as a micro-optimization.
+
+  function readWord1() {
+    containsEsc = false;
+    var word = "", first = true, chunkStart = tokPos;
+    while (tokPos < inputLen) {
+      var ch = input.charCodeAt(tokPos);
+      if (isIdentifierChar(ch)) {
+        ++tokPos;
+      } else if (ch === 92) { // "\"
+        containsEsc = true;
+        word += input.slice(chunkStart, tokPos);
+        if (input.charCodeAt(++tokPos) != 117) // "u"
+          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;
+        chunkStart = tokPos;
+      } else {
+        break;
+      }
+      first = false;
+    }
+    return word + input.slice(chunkStart, tokPos);
+  }
+
+  // Read an identifier or keyword token. Will check for reserved
+  // words when necessary.
+
+  function readWord() {
+    var word = readWord1();
+    var type = inXJSTag ? _xjsName : _name;
+    if (!containsEsc && isKeyword(word))
+      type = keywordTypes[word];
+    return finishToken(type, word);
+  }
+
+  // Read a JSX identifier (valid tag or attribute name).
+  //
+  // Optimized version since JSX identifiers can't contain
+  // escape characters and so can be read as single slice.
+  // Also assumes that first character was already checked
+  // by isIdentifierStart in readToken.
+
+  function readJSXWord() {
+    var ch, start = tokPos;
+    do {
+      ch = input.charCodeAt(++tokPos);
+    } while (isIdentifierChar(ch) || ch === 45); // '-'
+    return finishToken(_jsxName, input.slice(start, tokPos));
+  }
+
+  // ## Parser
+
+  // A recursive descent parser operates by defining functions for all
+  // syntactic elements, and recursively calling those, each function
+  // advancing the input stream and returning an AST node. Precedence
+  // of constructs (for example, the fact that `!x[1]` means `!(x[1])`
+  // instead of `(!x)[1]` is handled by the fact that the parser
+  // function that parses unary prefix operators is called first, and
+  // in turn calls the function that parses `[]` subscripts — that
+  // way, it'll receive the node for `x[1]` already parsed, and wraps
+  // *that* in the unary operator node.
+  //
+  // Acorn uses an [operator precedence parser][opp] to handle binary
+  // operator precedence, because it is much more compact than using
+  // the technique outlined above, which uses different, nesting
+  // functions to specify precedence, for all of the ten binary
+  // precedence levels that JavaScript defines.
+  //
+  // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
+
+  // ### Parser utilities
+
+  // Continue to the next token.
+
+  function next() {
+    if (options.onToken)
+      options.onToken(new Token());
+
+    lastStart = tokStart;
+    lastEnd = tokEnd;
+    lastEndLoc = tokEndLoc;
+    readToken();
+  }
+
+  // Enter strict mode. Re-reads the next number or string to
+  // please pedantic tests ("use strict"; 010; -- should fail).
+
+  function setStrict(strct) {
+    strict = strct;
+    if (tokType !== _num && tokType !== _string) return;
+    tokPos = tokStart;
+    if (options.locations) {
+      while (tokPos < tokLineStart) {
+        tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+        --tokCurLine;
+      }
+    }
+    skipSpace();
+    readToken();
+  }
+
+  // Start an AST node, attaching a start offset.
+
+  function Node() {
+    this.type = null;
+    this.start = tokStart;
+    this.end = null;
+  }
+  
+  exports.Node = Node;
+
+  function SourceLocation() {
+    this.start = tokStartLoc;
+    this.end = null;
+    if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+    var node = new exports.Node();
+    if (options.locations)
+      node.loc = new SourceLocation();
+    if (options.directSourceFile)
+      node.sourceFile = options.directSourceFile;
+    if (options.ranges)
+      node.range = [tokStart, 0];
+    return node;
+  }
+
+  // Sometimes, a node is only started *after* the token stream passed
+  // its start position. The functions below help storing a position
+  // and creating a node from a previous position.
+
+  function storeCurrentPos() {
+    return options.locations ? [tokStart, tokStartLoc] : tokStart;
+  }
+
+  function startNodeAt(pos) {
+    var node = new exports.Node(), start = pos;
+    if (options.locations) {
+      node.loc = new SourceLocation();
+      node.loc.start = start[1];
+      start = pos[0];
+    }
+    node.start = start;
+    if (options.directSourceFile)
+      node.sourceFile = options.directSourceFile;
+    if (options.ranges)
+      node.range = [start, 0];
+
+    return node;
+  }
+
+  // Finish an AST node, adding `type` and `end` properties.
+
+  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;
+  }
+
+  // Finish node at given position
+
+  function finishNodeAt(node, type, pos) {
+    if (options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
+    node.type = type;
+    node.end = pos;
+    if (options.ranges)
+      node.range[1] = pos;
+    return node;
+  }
+
+  // Test whether a statement node is the string literal `"use strict"`.
+
+  function isUseStrict(stmt) {
+    return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+      stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  // Predicate that tests whether the next token is of the given
+  // type, and if yes, consumes it as a side effect.
+
+  function eat(type) {
+    if (tokType === type) {
+      next();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // Tests whether parsed token is a contextual keyword.
+
+  function isContextual(name) {
+    return tokType === _name && tokVal === name;
+  }
+
+  // Consumes contextual keyword if possible.
+
+  function eatContextual(name) {
+    return tokVal === name && eat(_name);
+  }
+
+  // Asserts that following token is given contextual keyword.
+
+  function expectContextual(name) {
+    if (!eatContextual(name)) unexpected();
+  }
+
+  // Test whether a semicolon can be inserted at the current position.
+
+  function canInsertSemicolon() {
+    return !options.strictSemicolons &&
+      (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  // Consume a semicolon, or, failing that, see if we are allowed to
+  // pretend that there is a semicolon at this position.
+
+  function semicolon() {
+    if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  // Expect a token of a given type. If found, consume it, otherwise,
+  // raise an unexpected token error.
+
+  function expect(type) {
+    eat(type) || unexpected();
+  }
+
+  // Get following char.
+
+  function nextChar() {
+    return input.charAt(tokPos);
+  }
+
+  // Raise an unexpected token error.
+
+  function unexpected(pos) {
+    raise(pos != null ? pos : tokStart, "Unexpected token");
+  }
+
+  // Checks if hash object has a property.
+
+  function has(obj, propName) {
+    return Object.prototype.hasOwnProperty.call(obj, propName);
+  }
+
+  // Convert existing expression atom to assignable pattern
+  // if possible.
+
+  function toAssignable(node, isBinding) {
+    if (options.ecmaVersion >= 6 && node) {
+      switch (node.type) {
+        case "Identifier":
+        case "VirtualPropertyExpression":
+        case "MemberExpression":
+        case "ObjectPattern":
+        case "ArrayPattern":
+        case "AssignmentPattern":
+          break;
+
+        case "ObjectExpression":
+          node.type = "ObjectPattern";
+          for (var i = 0; i < node.properties.length; i++) {
+            var prop = node.properties[i];
+            if (prop.kind !== "init") raise(prop.key.start, "Object pattern can't contain getter or setter");
+            toAssignable(prop.value, isBinding);
+          }
+          break;
+
+        case "ArrayExpression":
+          node.type = "ArrayPattern";
+          toAssignableList(node.elements, isBinding);
+          break;
+
+        case "AssignmentExpression":
+          if (node.operator === "=") {
+            node.type = "AssignmentPattern";
+          } else {
+            raise(node.left.end, "Only '=' operator can be used for specifying default value.");
+          }
+          break;
+
+        case "MemberExpression":
+          if (!isBinding) break;
+
+        default:
+          raise(node.start, "Assigning to rvalue");
+      }
+    }
+    return node;
+  }
+
+  // Convert list of expression atoms to binding list.
+
+  function toAssignableList(exprList, isBinding) {
+    if (exprList.length) {
+      for (var i = 0; i < exprList.length - 1; i++) {
+        toAssignable(exprList[i], isBinding);
+      }
+      var last = exprList[exprList.length - 1];
+      switch (last.type) {
+        case "RestElement":
+          break;
+        case "SpreadElement":
+          last.type = "RestElement";
+          var arg = last.argument;
+          toAssignable(arg, isBinding);
+          if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
+            unexpected(arg.start);
+          break;
+        default:
+          toAssignable(last, isBinding);
+      }
+    }
+    return exprList;
+  }
+
+  // Parses spread element.
+
+  function parseSpread(refShorthandDefaultPos) {
+    var node = startNode();
+    next();
+    node.argument = parseMaybeAssign(refShorthandDefaultPos);
+    return finishNode(node, "SpreadElement");
+  }
+
+  function parseRest() {
+    var node = startNode();
+    next();
+    node.argument = tokType === _name || tokType === _bracketL ? parseBindingAtom() : unexpected();
+    return finishNode(node, "RestElement");
+  }
+
+  // Parses lvalue (assignable) atom.
+
+  function parseBindingAtom() {
+    if (options.ecmaVersion < 6) return parseIdent();
+    switch (tokType) {
+      case _name:
+        return parseIdent();
+
+      case _bracketL:
+        var node = startNode();
+        next();
+        node.elements = parseBindingList(_bracketR, true);
+        return finishNode(node, "ArrayPattern");
+
+      case _braceL:
+        return parseObj(true);
+
+      default:
+        unexpected();
+    }
+  }
+
+  function parseBindingList(close, allowEmpty) {
+    var elts = [], first = true;
+    while (!eat(close)) {
+      first ? first = false : expect(_comma);
+      if (tokType === _ellipsis) {
+        elts.push(parseAssignableListItemTypes(parseRest()));
+        expect(close);
+        break;
+      }
+      var elem;
+      if (allowEmpty && tokType === _comma) {
+        elem = null;
+      } else {
+        var left = parseMaybeDefault();
+        parseAssignableListItemTypes(left);
+        elem = parseMaybeDefault(null, left);
+      }
+      elts.push(elem);
+    }
+    return elts;
+  }
+
+  function parseAssignableListItemTypes(param) {
+    if (eat(_question)) {
+      param.optional = true;
+    }
+    if (tokType === _colon) {
+      param.typeAnnotation = parseTypeAnnotation();
+    }
+    finishNode(param, param.type);
+    return param;
+  }
+
+  // Parses assignment pattern around given atom if possible.
+
+  function parseMaybeDefault(startPos, left) {
+    startPos = startPos || storeCurrentPos();
+    left = left || parseBindingAtom();
+    if (!eat(_eq)) return left;
+    var node = startNodeAt(startPos);
+    node.operator = "=";
+    node.left = left;
+    node.right = parseMaybeAssign();
+    return finishNode(node, "AssignmentPattern");
+  }
+
+  // Verify that argument names are not repeated, and it does not
+  // try to bind the words `eval` or `arguments`.
+
+  function checkFunctionParam(param, nameHash) {
+    switch (param.type) {
+      case "Identifier":
+        if (isStrictReservedWord(param.name) || isStrictBadIdWord(param.name))
+          raise(param.start, "Defining '" + param.name + "' in strict mode");
+        if (has(nameHash, param.name))
+          raise(param.start, "Argument name clash in strict mode");
+        nameHash[param.name] = true;
+        break;
+
+      case "ObjectPattern":
+        for (var i = 0; i < param.properties.length; i++) {
+          var param2 = param.properties[i];
+          if (param2.type === "SpreadProperty") {
+            checkFunctionParam(param2.argument, nameHash);
+          } else {
+            checkFunctionParam(param2.value, nameHash);
+          }
+        }
+        break;
+
+      case "ArrayPattern":
+        for (var i = 0; i < param.elements.length; i++) {
+          var elem = param.elements[i];
+          if (elem) checkFunctionParam(elem, nameHash);
+        }
+        break;
+
+      case "RestElement":
+        return checkFunctionParam(param.argument, nameHash);
+    }
+  }
+
+  // Check if property name clashes with already added.
+  // Object/class getters and setters are not allowed to clash —
+  // either with each other or with an init property — and in
+  // strict mode, init properties are also not allowed to be repeated.
+
+  function checkPropClash(prop, propHash) {
+    if (options.ecmaVersion >= 6) return;
+    var key = prop.key, name;
+    switch (key.type) {
+      case "Identifier": name = key.name; break;
+      case "Literal": name = String(key.value); break;
+      default: return;
+    }
+    var kind = prop.kind || "init", other;
+    if (has(propHash, name)) {
+      other = propHash[name];
+      var isGetSet = kind !== "init";
+      if ((strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
+        raise(key.start, "Redefinition of property");
+    } else {
+      other = propHash[name] = {
+        init: false,
+        get: false,
+        set: false
+      };
+    }
+    other[kind] = true;
+  }
+
+  // Verify that a node is an lval — something that can be assigned
+  // to.
+
+  function checkLVal(expr, isBinding) {
+    switch (expr.type) {
+      case "Identifier":
+        if (strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
+          raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
+        break;
+      
+      case "MemberExpression":
+        if (isBinding) raise(expr.start, "Binding to member expression");
+        break;
+
+      case "ObjectPattern":
+        for (var i = 0; i < expr.properties.length; i++) {
+          var prop = expr.properties[i];
+          if (prop.type === "Property") prop = prop.value;
+          checkLVal(prop, isBinding);
+        }
+        break;
+
+      case "ArrayPattern":
+        for (var i = 0; i < expr.elements.length; i++) {
+          var elem = expr.elements[i];
+          if (elem) checkLVal(elem, isBinding);
+        }
+        break;
+
+      case "AssignmentPattern":
+        checkLVal(expr.left);
+        break;
+
+      case "SpreadProperty":
+      case "VirtualPropertyExpression":
+        break;
+
+      case "RestElement":
+        checkLVal(expr.argument);
+        break;
+
+      default:
+      raise(expr.start, "Assigning to rvalue");
+  }
+  }
+
+  // ### Statement parsing
+
+  // Parse a program. Initializes the parser, reads any number of
+  // statements, and wraps them in a Program node.  Optionally takes a
+  // `program` argument.  If present, the statements will be appended
+  // to its body instead of creating a new exports.Node.
+
+  function parseTopLevel(node) {
+    var first = true;
+    if (!node.body) node.body = [];
+    while (tokType !== _eof) {
+      var stmt = parseStatement(true, true);
+      node.body.push(stmt);
+      if (first && isUseStrict(stmt)) setStrict(true);
+      first = false;
+    }
+
+    next();
+    return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  // Parse a single statement.
+  //
+  // If expecting a statement and finding a slash operator, parse a
+  // regular expression literal. This is to handle cases like
+  // `if (foo) /blah/.exec(foo);`, where looking at the previous token
+  // does not help.
+
+  function parseStatement(declaration, topLevel) {
+    var starttype = tokType, node = startNode();
+
+    // Most types of statements are recognized by the keyword they
+    // start with. Many are trivial to parse, some require a bit of
+    // complexity.
+
+    switch (starttype) {
+    case _break: case _continue: return parseBreakContinueStatement(node, starttype.keyword);
+    case _debugger: return parseDebuggerStatement(node);
+    case _do: return parseDoStatement(node);
+    case _for: return parseForStatement(node);
+    case _function:
+      if (!declaration && options.ecmaVersion >= 6) unexpected();
+      return parseFunctionStatement(node);
+    case _class:
+      if (!declaration) unexpected();
+      return parseClass(node, true);
+    case _if: return parseIfStatement(node);
+    case _return: return parseReturnStatement(node);
+    case _switch: return parseSwitchStatement(node);
+    case _throw: return parseThrowStatement(node);
+    case _try: return parseTryStatement(node);
+    case _let: case _const: if (!declaration) unexpected(); // NOTE: falls through to _var
+    case _var: return parseVarStatement(node, starttype.keyword);
+    case _while: return parseWhileStatement(node);
+    case _with: return parseWithStatement(node);
+    case _braceL: return parseBlock(); // no point creating a function for this
+    case _semi: return parseEmptyStatement(node);
+    case _export:
+    case _import:
+      if (!topLevel && !options.allowImportExportEverywhere)
+        raise(tokStart, "'import' and 'export' may only appear at the top level");
+      return starttype === _import ? parseImport(node) : parseExport(node);
+
+    case _name:
+      if (options.ecmaVersion >= 7 && tokType === _name) {
+        if (tokVal === "private") {
+          next();
+          return parsePrivate(node);
+        }
+
+        if (tokVal === "async") {
+          // check to see if `function ` appears after this token, this is
+          // pretty hacky
+          if (input.slice(tokEnd + 1, tokEnd + 10) === "function ") {
+            next();
+            expect(_function);
+            return parseFunction(node, true, true);
+          }
+        }
+      }
+
+      // If the statement does not start with a statement keyword or a
+      // brace, it's an ExpressionStatement or LabeledStatement. We
+      // simply start parsing an expression, and afterwards, if the
+      // next token is a colon and the expression was a simple
+      // Identifier node, we switch to interpreting it as a label.
+    default:
+      var maybeName = tokVal, expr = parseExpression();
+
+      if (starttype === _name && expr.type === "Identifier") {
+        if (eat(_colon)) {
+          return parseLabeledStatement(node, maybeName, expr);
+        }
+
+        if (expr.name === "declare") {
+          if (tokType === _class || tokType === _name || tokType === _function || tokType === _var) {
+            return parseDeclare(node);
+          }
+        } else if (tokType === _name) {
+          if (expr.name === "interface") {
+            return parseInterface(node);
+          } else if (expr.name === "type") {
+            return parseTypeAlias(node);
+          }
+        }
+      }
+
+      return parseExpressionStatement(node, expr);
+    }
+  }
+  
+  function parseBreakContinueStatement(node, keyword) {
+    var isBreak = keyword == "break";
+    next();
+    if (eat(_semi) || canInsertSemicolon()) node.label = null;
+    else if (tokType !== _name) unexpected();
+    else {
+      node.label = parseIdent();
+      semicolon();
+    }
+
+    // Verify that there is an actual destination to break or
+    // continue to.
+    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 " + keyword);
+    return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+  }
+  
+  function parseDebuggerStatement(node) {
+    next();
+    semicolon();
+    return finishNode(node, "DebuggerStatement");
+  }
+  
+  function parseDoStatement(node) {
+    next();
+    labels.push(loopLabel);
+    node.body = parseStatement(false);
+    labels.pop();
+    expect(_while);
+    node.test = parseParenExpression();
+    if (options.ecmaVersion >= 6)
+      eat(_semi);
+    else
+      semicolon();
+    return finishNode(node, "DoWhileStatement");
+  }
+  
+  // Disambiguating between a `for` and a `for`/`in` or `for`/`of`
+  // loop is non-trivial. Basically, we have to parse the init `var`
+  // statement or expression, disallowing the `in` operator (see
+  // the second parameter to `parseExpression`), and then check
+  // whether the next token is `in` or `of`. When there is no init
+  // part (semicolon immediately after the opening parenthesis), it
+  // is a regular `for` loop.
+  
+  function parseForStatement(node) {
+    next();
+    labels.push(loopLabel);
+    expect(_parenL);
+    if (tokType === _semi) return parseFor(node, null);
+    if (tokType === _var || tokType === _let) {
+      var init = startNode(), varKind = tokType.keyword, isLet = tokType === _let;
+      next();
+      parseVar(init, true, varKind);
+      finishNode(init, "VariableDeclaration");
+      if ((tokType === _in || (options.ecmaVersion >= 6 && isContextual("of"))) && init.declarations.length === 1 &&
+          !(isLet && init.declarations[0].init))
+        return parseForIn(node, init);
+      return parseFor(node, init);
+    }
+    var refShorthandDefaultPos = {start: 0};
+    var init = parseExpression(true, refShorthandDefaultPos);
+    if (tokType === _in || (options.ecmaVersion >= 6 && isContextual("of"))) {
+      toAssignable(init);
+      checkLVal(init);
+      return parseForIn(node, init);
+    } else if (refShorthandDefaultPos.start) {
+      unexpected(refShorthandDefaultPos.start);
+    }
+    return parseFor(node, init);
+  }
+  
+  function parseFunctionStatement(node) {
+    next();
+    return parseFunction(node, true, false);
+  }
+  
+  function parseIfStatement(node) {
+    next();
+    node.test = parseParenExpression();
+    node.consequent = parseStatement(false);
+    node.alternate = eat(_else) ? parseStatement(false) : null;
+    return finishNode(node, "IfStatement");
+  }
+  
+  function parseReturnStatement(node) {
+    if (!inFunction && !options.allowReturnOutsideFunction)
+      raise(tokStart, "'return' outside of function");
+    next();
+
+    // In `return` (and `break`/`continue`), the keywords with
+    // optional arguments, we eagerly look for a semicolon or the
+    // possibility to insert one.
+
+    if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+    else { node.argument = parseExpression(); semicolon(); }
+    return finishNode(node, "ReturnStatement");
+  }
+  
+  function parseSwitchStatement(node) {
+    next();
+    node.discriminant = parseParenExpression();
+    node.cases = [];
+    expect(_braceL);
+    labels.push(switchLabel);
+
+    // Statements under must be grouped (by label) in SwitchCase
+    // nodes. `cur` is used to keep the node that we are currently
+    // adding statements to.
+
+    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(true));
+      }
+    }
+    if (cur) finishNode(cur, "SwitchCase");
+    next(); // Closing brace
+    labels.pop();
+    return finishNode(node, "SwitchStatement");
+  }
+  
+  function parseThrowStatement(node) {
+    next();
+    if (newline.test(input.slice(lastEnd, tokStart)))
+      raise(lastEnd, "Illegal newline after throw");
+    node.argument = parseExpression();
+    semicolon();
+    return finishNode(node, "ThrowStatement");
+  }
+  
+  function parseTryStatement(node) {
+    next();
+    node.block = parseBlock();
+    node.handler = null;
+    if (tokType === _catch) {
+      var clause = startNode();
+      next();
+      expect(_parenL);
+      clause.param = parseBindingAtom();
+      checkLVal(clause.param, true);
+      expect(_parenR);
+      clause.guard = null;
+      clause.body = parseBlock();
+      node.handler = finishNode(clause, "CatchClause");
+    }
+    node.guardedHandlers = empty;
+    node.finalizer = eat(_finally) ? parseBlock() : null;
+    if (!node.handler && !node.finalizer)
+      raise(node.start, "Missing catch or finally clause");
+    return finishNode(node, "TryStatement");
+  }
+  
+  function parseVarStatement(node, kind) {
+    next();
+    parseVar(node, false, kind);
+    semicolon();
+    return finishNode(node, "VariableDeclaration");
+  }
+  
+  function parseWhileStatement(node) {
+    next();
+    node.test = parseParenExpression();
+    labels.push(loopLabel);
+    node.body = parseStatement(false);
+    labels.pop();
+    return finishNode(node, "WhileStatement");
+  }
+  
+  function parseWithStatement(node) {
+    if (strict) raise(tokStart, "'with' in strict mode");
+    next();
+    node.object = parseParenExpression();
+    node.body = parseStatement(false);
+    return finishNode(node, "WithStatement");
+  }
+  
+  function parseEmptyStatement(node) {
+    next();
+    return finishNode(node, "EmptyStatement");
+  }
+  
+  function parseLabeledStatement(node, maybeName, expr) {
+    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: kind});
+    node.body = parseStatement(true);
+    labels.pop();
+    node.label = expr;
+    return finishNode(node, "LabeledStatement");
+  }
+  
+  function parseExpressionStatement(node, expr) {
+    node.expression = expr;
+    semicolon();
+    return finishNode(node, "ExpressionStatement");
+  }
+
+  // Used for constructs like `switch` and `if` that insist on
+  // parentheses around their expression.
+
+  function parseParenExpression() {
+    expect(_parenL);
+    var val = parseExpression();
+    expect(_parenR);
+    return val;
+  }
+
+  // Parse a semicolon-enclosed block of statements, handling `"use
+  // strict"` declarations when `allowStrict` is true (used for
+  // function bodies).
+
+  function parseBlock(allowStrict) {
+    var node = startNode(), first = true, oldStrict;
+    node.body = [];
+    expect(_braceL);
+    while (!eat(_braceR)) {
+      var stmt = parseStatement(true);
+      node.body.push(stmt);
+      if (first && allowStrict && isUseStrict(stmt)) {
+        oldStrict = strict;
+        setStrict(strict = true);
+      }
+      first = false;
+    }
+    if (oldStrict === false) setStrict(false);
+    return finishNode(node, "BlockStatement");
+  }
+
+  // Parse a regular `for` loop. The disambiguation code in
+  // `parseStatement` will already have parsed the init statement or
+  // expression.
+
+  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(false);
+    labels.pop();
+    return finishNode(node, "ForStatement");
+  }
+
+  // Parse a `for`/`in` and `for`/`of` loop, which are almost
+  // same from parser's perspective.
+
+  function parseForIn(node, init) {
+    var type = tokType === _in ? "ForInStatement" : "ForOfStatement";
+    next();
+    node.left = init;
+    node.right = parseExpression();
+    expect(_parenR);
+    node.body = parseStatement(false);
+    labels.pop();
+    return finishNode(node, type);
+  }
+
+  // Parse a list of variable declarations.
+
+  function parseVar(node, noIn, kind) {
+    node.declarations = [];
+    node.kind = kind;
+    for (;;) {
+      var decl = startNode();
+      decl.id = parseBindingAtom();
+      checkLVal(decl.id, true);
+
+      if (tokType === _colon) {
+        decl.id.typeAnnotation = parseTypeAnnotation();
+        finishNode(decl.id, decl.id.type);
+      }
+
+      decl.init = eat(_eq) ? parseMaybeAssign(noIn) : (kind === _const.keyword ? unexpected() : null);
+      node.declarations.push(finishNode(decl, "VariableDeclarator"));
+      if (!eat(_comma)) break;
+    }
+    return node;
+  }
+
+  // ### Expression parsing
+
+  // These nest, from the most general expression type at the top to
+  // 'atomic', nondivisible expression types at the bottom. Most of
+  // the functions will simply let the function(s) below them parse,
+  // and, *if* the syntactic construct they handle is present, wrap
+  // the AST node that the inner parser gave them in another node.
+
+  // Parse a full expression. The optional arguments are used to
+  // forbid the `in` operator (in for loops initalization expressions)
+  // and provide reference for storing '=' operator inside shorthand
+  // property assignment in contexts where both object expression
+  // and object pattern might appear (so it's possible to raise
+  // delayed syntax error at correct position).
+
+  function parseExpression(noIn, refShorthandDefaultPos) {
+    var start = storeCurrentPos();
+    var expr = parseMaybeAssign(noIn, refShorthandDefaultPos);
+    if (tokType === _comma) {
+      var node = startNodeAt(start);
+      node.expressions = [expr];
+      while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn, refShorthandDefaultPos));
+      return finishNode(node, "SequenceExpression");
+    }
+    return expr;
+  }
+
+  // Parse an assignment expression. This includes applications of
+  // operators like `+=`.
+
+  function parseMaybeAssign(noIn, refShorthandDefaultPos, afterLeftParse) {
+    var failOnShorthandAssign;
+    if (!refShorthandDefaultPos) {
+      refShorthandDefaultPos = {start: 0};
+      failOnShorthandAssign = true;
+    } else {
+      failOnShorthandAssign = false;
+    }
+    var start = storeCurrentPos();
+    var left = parseMaybeConditional(noIn, refShorthandDefaultPos);
+    if (afterLeftParse) left = afterLeftParse(left, start);
+    if (tokType.isAssign) {
+      var node = startNodeAt(start);
+      node.operator = tokVal;
+      node.left = tokType === _eq ? toAssignable(left) : left;
+      refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
+      checkLVal(left);
+      next();
+      node.right = parseMaybeAssign(noIn);
+      return finishNode(node, "AssignmentExpression");
+    } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
+      unexpected(refShorthandDefaultPos.start);
+    }
+    return left;
+  }
+
+  // Parse a ternary conditional (`?:`) operator.
+
+  function parseMaybeConditional(noIn, refShorthandDefaultPos) {
+    var start = storeCurrentPos();
+    var expr = parseExprOps(noIn, refShorthandDefaultPos);
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+    if (eat(_question)) {
+      var node = startNodeAt(start);
+      if (options.playground && eat(_eq)) {
+        var left = node.left = toAssignable(expr);
+        if (left.type !== "MemberExpression") raise(left.start, "You can only use member expressions in memoization assignment");
+        node.right = parseMaybeAssign(noIn);
+        node.operator = "?=";
+        return finishNode(node, "AssignmentExpression");
+      }
+      node.test = expr;
+      node.consequent = parseMaybeAssign();
+      expect(_colon);
+      node.alternate = parseMaybeAssign(noIn);
+      return finishNode(node, "ConditionalExpression");
+    }
+    return expr;
+  }
+
+  // Start the precedence parser.
+
+  function parseExprOps(noIn, refShorthandDefaultPos) {
+    var start = storeCurrentPos();
+    var expr = parseMaybeUnary(refShorthandDefaultPos);
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+    return parseExprOp(expr, start, -1, noIn);
+  }
+
+  // Parse binary operators with the operator precedence parsing
+  // algorithm. `left` is the left-hand side of the operator.
+  // `minPrec` provides context that allows the function to stop and
+  // defer further parser to one of its callers when it encounters an
+  // operator that has a lower precedence than the set it is parsing.
+
+  function parseExprOp(left, leftStart, minPrec, noIn) {
+    var prec = tokType.binop;
+    if (prec != null && (!noIn || tokType !== _in)) {
+      if (prec > minPrec) {
+        var node = startNodeAt(leftStart);
+        node.left = left;
+        node.operator = tokVal;
+        var op = tokType;
+        next();
+        var start = storeCurrentPos();
+        node.right = parseExprOp(parseMaybeUnary(), start, op.rightAssociative ? (prec - 1) : prec, noIn);
+        finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+        return parseExprOp(node, leftStart, minPrec, noIn);
+      }
+    }
+    return left;
+  }
+
+  // Parse unary operators, both prefix and postfix.
+
+  function parseMaybeUnary(refShorthandDefaultPos) {
+    if (tokType.prefix) {
+      var node = startNode(), update = tokType.isUpdate;
+      node.operator = tokVal;
+      node.prefix = true;
+      next();
+      node.argument = parseMaybeUnary();
+      if (refShorthandDefaultPos && refShorthandDefaultPos.start) unexpected(refShorthandDefaultPos.start);
+      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 start = storeCurrentPos();
+    var expr = parseExprSubscripts(refShorthandDefaultPos);
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+    while (tokType.postfix && !canInsertSemicolon()) {
+      var node = startNodeAt(start);
+      node.operator = tokVal;
+      node.prefix = false;
+      node.argument = expr;
+      checkLVal(expr);
+      next();
+      expr = finishNode(node, "UpdateExpression");
+    }
+    return expr;
+  }
+
+  // Parse call, dot, and `[]`-subscript expressions.
+
+  function parseExprSubscripts(refShorthandDefaultPos) {
+    var start = storeCurrentPos();
+    var expr = parseExprAtom(refShorthandDefaultPos);
+    if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
+    return parseSubscripts(expr, start);
+  }
+
+  function parseSubscripts(base, start, noCalls) {
+    if (options.playground && eat(_hash)) {
+      var node = startNodeAt(start);
+      node.object = base;
+      node.property = parseIdent(true);
+      if (eat(_parenL)) {
+        node.arguments = parseExprList(_parenR, false);
+      } else {
+        node.arguments = [];
+      }
+      return parseSubscripts(finishNode(node, "BindMemberExpression"), start, noCalls);
+    } else if (eat(_paamayimNekudotayim)) {
+      var node = startNodeAt(start);
+      node.object = base;
+      node.property = parseIdent(true);
+      return parseSubscripts(finishNode(node, "VirtualPropertyExpression"), start, noCalls);
+    } else if (eat(_dot)) {
+      var node = startNodeAt(start);
+      node.object = base;
+      node.property = parseIdent(true);
+      node.computed = false;
+      return parseSubscripts(finishNode(node, "MemberExpression"), start, noCalls);
+    } else if (eat(_bracketL)) {
+      var node = startNodeAt(start);
+      node.object = base;
+      node.property = parseExpression();
+      node.computed = true;
+      expect(_bracketR);
+      return parseSubscripts(finishNode(node, "MemberExpression"), start, noCalls);
+    } else if (!noCalls && eat(_parenL)) {
+      var node = startNodeAt(start);
+      node.callee = base;
+      node.arguments = parseExprList(_parenR, false);
+      return parseSubscripts(finishNode(node, "CallExpression"), start, noCalls);
+    } else if (tokType === _backQuote) {
+      var node = startNodeAt(start);
+      node.tag = base;
+      node.quasi = parseTemplate();
+      return parseSubscripts(finishNode(node, "TaggedTemplateExpression"), start, noCalls);
+    } return base;
+  }
+
+  // Parse an atomic expression — either a single token that is an
+  // expression, an expression started by a keyword like `function` or
+  // `new`, or an expression wrapped in punctuation like `()`, `[]`,
+  // or `{}`.
+
+  function parseExprAtom(refShorthandDefaultPos) {
+    switch (tokType) {
+    case _this:
+      var node = startNode();
+      next();
+      return finishNode(node, "ThisExpression");
+    
+    case _yield:
+      if (inGenerator) return parseYield();
+
+    case _name:
+      var start = storeCurrentPos();
+      var node = startNode();
+      var id = parseIdent(tokType !== _name);
+
+      if (options.ecmaVersion >= 7) {
+        // async functions!
+        if (id.name === "async") {
+          // arrow functions
+          if (tokType === _parenL) {
+            var expr = parseParenAndDistinguishExpression(start, true);
+            if (expr.type === "ArrowFunctionExpression") {
+              return expr;
+            } else {
+              node.callee = id;
+              if (expr.type === "SequenceExpression") {
+                node.arguments = expr.expressions;
+              } else {
+                node.arguments = [expr];
+              }
+              return parseSubscripts(finishNode(node, "CallExpression"), start);
+            }
+          } else if (tokType === _name) {
+            id = parseIdent();
+            expect(_arrow);
+            return parseArrowExpression(node, [id], true);
+          }
+
+          // normal functions
+          if (tokType === _function && !canInsertSemicolon()) {
+            next();
+            return parseFunction(node, false, true);
+          }
+        } else if (id.name === "await") {
+          if (inAsync) return parseAwait(node);
+        }
+      }
+
+      if (!canInsertSemicolon() && eat(_arrow)) {
+        return parseArrowExpression(startNodeAt(start), [id]);
+      }
+      return id;
+      
+    case _regexp:
+      var node = startNode();
+      node.regex = {pattern: tokVal.pattern, flags: tokVal.flags};
+      node.value = tokVal.value;
+      node.raw = input.slice(tokStart, tokEnd);
+      next();
+      return finishNode(node, "Literal");
+
+    case _num: case _string: case _jsxText:
+      var node = startNode();
+      node.value = tokVal;
+      node.raw = input.slice(tokStart, tokEnd);
+      next();
+      return finishNode(node, "Literal");
+
+    case _null: case _true: case _false:
+      var node = startNode();
+      node.value = tokType.atomValue;
+      node.raw = tokType.keyword;
+      next();
+      return finishNode(node, "Literal");
+
+    case _parenL:
+      return parseParenAndDistinguishExpression();
+
+    case _bracketL:
+      var node = startNode();
+      next();
+      // check whether this is array comprehension or regular array
+      if (options.ecmaVersion >= 7 && tokType === _for) {
+        return parseComprehension(node, false);
+      }
+      node.elements = parseExprList(_bracketR, true, true, refShorthandDefaultPos);
+      return finishNode(node, "ArrayExpression");
+
+    case _braceL:
+      return parseObj(false, refShorthandDefaultPos);
+
+    case _function:
+      var node = startNode();
+      next();
+      return parseFunction(node, false, false);
+
+    case _class:
+      return parseClass(startNode(), false);
+
+    case _new:
+      return parseNew();
+
+    case _backQuote:
+      return parseTemplate();
+
+    case _hash:
+      return parseBindFunctionExpression();
+
+    case _jsxTagStart:
+      return parseJSXElement();
+
+    default:
+      unexpected();
+    }
+  }
+
+  function parseBindFunctionExpression() {
+    var node = startNode();
+    next();
+
+    var start = storeCurrentPos();
+    node.callee = parseSubscripts(parseExprAtom(), start, true);
+
+    if (eat(_parenL)) {
+      node.arguments = parseExprList(_parenR, false);
+    } else {
+      node.arguments = [];
+    }
+
+    return finishNode(node, "BindFunctionExpression");
+  }
+
+  function parseParenAndDistinguishExpression(start, isAsync) {
+    start = start || storeCurrentPos();
+    var val;
+    if (options.ecmaVersion >= 6) {
+      next();
+
+      if (options.ecmaVersion >= 7 && tokType === _for) {
+        return parseComprehension(startNodeAt(start), true);
+      }
+
+      var innerStart = storeCurrentPos(), exprList = [], first = true;
+      var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart, typeStart;
+
+      var parseParenItem = function (node, start) {
+        if (tokType === _colon) {
+          var typeCastNode = startNodeAt(start);
+          typeCastNode.expression = node;
+          typeCastNode.typeAnnotation = parseTypeAnnotation();
+          return finishNode(typeCastNode, "TypeCastExpression");
+        } else {
+          return node;
+        }
+      };
+
+      while (tokType !== _parenR) {
+        first ? first = false : expect(_comma);
+        if (tokType === _ellipsis) {
+          var spreadNodeStart = storeCurrentPos();
+          spreadStart = tokStart;
+          exprList.push(parseParenItem(parseRest(), spreadNodeStart));
+          break;
+        } else {
+          if (tokType === _parenL && !innerParenStart) {
+            innerParenStart = tokStart;
+          }
+          exprList.push(parseMaybeAssign(false, refShorthandDefaultPos, parseParenItem));
+        }
+      }
+      var innerEnd = storeCurrentPos();
+      expect(_parenR);
+
+      if (!canInsertSemicolon() && eat(_arrow)) {
+        if (innerParenStart) unexpected(innerParenStart);
+
+        for (var i = 0; i < exprList.length; i++) {
+          var listItem = exprList[i];
+          if (listItem.type === "TypeCastExpression") {
+            var expr = listItem.expression;
+            expr.returnType = listItem.typeAnnotation;
+            exprList[i] = expr;
+          }
+        }
+
+        return parseArrowExpression(startNodeAt(start), exprList, isAsync);
+      }
+
+      if (!exprList.length) unexpected(lastStart);
+      if (spreadStart) unexpected(spreadStart);
+      if (refShorthandDefaultPos.start) unexpected(refShorthandDefaultPos.start);
+
+      //
+
+      if (exprList.length > 1) {
+        val = startNodeAt(innerStart);
+        val.expressions = exprList;
+        finishNodeAt(val, "SequenceExpression", innerEnd);
+      } else {
+        val = exprList[0];
+      }
+    } else {
+      val = parseParenExpression();
+    }
+
+    if (options.preserveParens) {
+      var par = startNodeAt(start);
+      par.expression = val;
+      return finishNode(par, "ParenthesizedExpression");
+    } else {
+      return val;
+    }
+  }
+
+  // New's precedence is slightly tricky. It must allow its argument
+  // to be a `[]` or dot subscript expression, but not a call — at
+  // least, not without wrapping it in parentheses. Thus, it uses the
+
+  function parseNew() {
+    var node = startNode();
+    next();
+    var start = storeCurrentPos();
+    node.callee = parseSubscripts(parseExprAtom(), start, true);
+    if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+    else node.arguments = empty;
+    return finishNode(node, "NewExpression");
+  }
+
+  // Parse template expression.
+
+  function parseTemplateElement() {
+    var elem = startNode();
+    elem.value = {
+      raw: input.slice(tokStart, tokEnd),
+      cooked: tokVal
+    };
+    next();
+    elem.tail = tokType === _backQuote;
+    return finishNode(elem, "TemplateElement");
+  }
+
+  function parseTemplate() {
+    var node = startNode();
+    next();
+    node.expressions = [];
+    var curElt = parseTemplateElement();
+    node.quasis = [curElt];
+    while (!curElt.tail) {
+      expect(_dollarBraceL);
+      node.expressions.push(parseExpression());
+      expect(_braceR);
+      node.quasis.push(curElt = parseTemplateElement());
+    }
+    next();
+    return finishNode(node, "TemplateLiteral");
+  }
+
+  // Parse an object literal or binding pattern.
+
+  function parseObj(isPattern, refShorthandDefaultPos) {
+    var node = startNode(), first = true, propHash = {};
+    node.properties = [];
+    next();
+    while (!eat(_braceR)) {
+      if (!first) {
+        expect(_comma);
+        if (options.allowTrailingCommas && eat(_braceR)) break;
+      } else first = false;
+
+      var prop = startNode(), start, isGenerator = false, isAsync = false;
+      if (options.ecmaVersion >= 7 && tokType === _ellipsis) {
+        prop = parseSpread();
+        prop.type = "SpreadProperty";
+        node.properties.push(prop);
+        continue;
+      }
+      if (options.ecmaVersion >= 6) {
+        prop.method = false;
+        prop.shorthand = false;
+        if (isPattern || refShorthandDefaultPos) {
+          start = storeCurrentPos();
+        }
+        if (!isPattern) {
+          isGenerator = eat(_star);
+        }
+      }
+      if (options.ecmaVersion >= 7 && isContextual("async")) {
+        var asyncId = parseIdent();
+        if (tokType === _colon || tokType === _parenL) {
+          prop.key = asyncId;
+        } else {
+          isAsync = true;
+          parsePropertyName(prop);
+        }
+      } else {
+        parsePropertyName(prop);
+      }
+      var typeParameters
+      if (isRelational("<")) {
+        typeParameters = parseTypeParameterDeclaration();
+        if (tokType !== _parenL) unexpected();
+      }
+      if (eat(_colon)) {
+        prop.value = isPattern ? parseMaybeDefault() : parseMaybeAssign(false, refShorthandDefaultPos);
+        prop.kind = "init";
+      } else if (options.ecmaVersion >= 6 && tokType === _parenL) {
+        if (isPattern) unexpected();
+        prop.kind = "init";
+        prop.method = true;
+        prop.value = parseMethod(isGenerator, isAsync);
+      } else if (options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+                 (prop.key.name === "get" || prop.key.name === "set" || (options.playground && prop.key.name === "memo")) &&
+                 (tokType != _comma && tokType != _braceR)) {
+        if (isGenerator || isAsync || isPattern) unexpected();
+        prop.kind = prop.key.name;
+        parsePropertyName(prop);
+        prop.value = parseMethod(false, false);
+      } else if (options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+        prop.kind = "init";
+        if (isPattern) {
+          prop.value = parseMaybeDefault(start, prop.key);
+        } else if (tokType === _eq && refShorthandDefaultPos) {
+          if (!refShorthandDefaultPos.start)
+            refShorthandDefaultPos.start = tokStart;
+          prop.value = parseMaybeDefault(start, prop.key);
+        } else {
+          prop.value = prop.key;
+        }
+        prop.shorthand = true;
+      } else unexpected();
+
+      prop.value.typeParameters = typeParameters;
+      checkPropClash(prop, propHash);
+      node.properties.push(finishNode(prop, "Property"));
+    }
+    return finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
+  }
+
+  function parsePropertyName(prop) {
+    if (options.ecmaVersion >= 6) {
+      if (eat(_bracketL)) {
+        prop.computed = true;
+        prop.key = parseExpression();
+        expect(_bracketR);
+        return;
+      } else {
+        prop.computed = false;
+      }
+    }
+    prop.key = (tokType === _num || tokType === _string) ? parseExprAtom() : parseIdent(true);
+  }
+
+  // Initialize empty function node.
+
+  function initFunction(node, isAsync) {
+    node.id = null;
+    if (options.ecmaVersion >= 6) {
+      node.generator = false;
+      node.expression = false;
+    }
+    if (options.ecmaVersion >= 7) {
+      node.async = isAsync;
+    }
+  }
+
+  // Parse a function declaration or literal (depending on the
+  // `isStatement` parameter).
+
+  function parseFunction(node, isStatement, isAsync, allowExpressionBody) {
+    initFunction(node, isAsync);
+    if (options.ecmaVersion >= 6) {
+      node.generator = eat(_star);
+    }
+    if (isStatement || tokType === _name) {
+      node.id = parseIdent();
+    }
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterDeclaration();
+    }
+    parseFunctionParams(node);
+    parseFunctionBody(node, allowExpressionBody);
+    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  // Parse object or class method.
+
+  function parseMethod(isGenerator, isAsync) {
+    var node = startNode();
+    initFunction(node, isAsync);
+    parseFunctionParams(node);
+    var allowExpressionBody;
+    if (options.ecmaVersion >= 6) {
+      node.generator = isGenerator;
+      allowExpressionBody = true;
+    } else {
+      allowExpressionBody = false;
+    }
+    parseFunctionBody(node, allowExpressionBody);
+    return finishNode(node, "FunctionExpression");
+  }
+
+  function parseFunctionParams(node) {
+    expect(_parenL);
+    node.params = parseBindingList(_parenR, false);
+    if (tokType === _colon) {
+      node.returnType = parseTypeAnnotation();
+    }
+  }
+
+  // Parse arrow function expression with given parameters.
+
+  function parseArrowExpression(node, params, isAsync) {
+    initFunction(node, isAsync);
+    node.params = toAssignableList(params, true);
+    parseFunctionBody(node, true);
+    return finishNode(node, "ArrowFunctionExpression");
+  }
+
+  // Parse function body and check parameters.
+
+  function parseFunctionBody(node, allowExpression) {
+    var isExpression = allowExpression && tokType !== _braceL;
+
+    var oldInAsync = inAsync;
+    inAsync = node.async;
+    if (isExpression) {
+      node.body = parseMaybeAssign();
+      node.expression = true;
+    } else {
+    // Start a new scope with regard to labels and the `inFunction`
+    // flag (restore them to their old value afterwards).
+      var oldInFunc = inFunction, oldInGen = inGenerator, oldLabels = labels;
+      inFunction = true; inGenerator = node.generator; labels = [];
+      node.body = parseBlock(true);
+      node.expression = false;
+      inFunction = oldInFunc; inGenerator = oldInGen; labels = oldLabels;
+    }
+    inAsync = oldInAsync;
+
+    // If this is a strict mode function, verify that argument names
+    // are not repeated, and it does not try to bind the words `eval`
+    // or `arguments`.
+    if (strict || !isExpression && node.body.body.length && isUseStrict(node.body.body[0])) {
+      var nameHash = {};
+      if (node.id)
+        checkFunctionParam(node.id, {});
+      for (var i = 0; i < node.params.length; i++)
+        checkFunctionParam(node.params[i], nameHash);
+    }
+  }
+
+  function parsePrivate(node) {
+    node.declarations = [];
+    do {
+      node.declarations.push(parseIdent());
+    } while (eat(_comma));
+    semicolon();
+    return finishNode(node, "PrivateDeclaration");
+  }
+
+  // Parse a class declaration or literal (depending on the
+  // `isStatement` parameter).
+  
+  function parseClass(node, isStatement) {
+    next();
+    node.id = tokType === _name ? parseIdent() : isStatement ? unexpected() : null;
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterDeclaration();
+    }
+    node.superClass = eat(_extends) ? parseExprSubscripts() : null;
+    if (node.superClass && isRelational("<")) {
+      node.superTypeParameters = parseTypeParameterInstantiation();
+    }
+    if (isContextual("implements")) {
+      next();
+      node.implements = parseClassImplements();
+    }
+    var classBody = startNode();
+    classBody.body = [];
+    expect(_braceL);
+    while (!eat(_braceR)) {
+      if (eat(_semi)) continue;
+      var method = startNode();
+      if (options.ecmaVersion >= 7 && isContextual("private")) {
+        next();
+        classBody.body.push(parsePrivate(method));
+        continue;
+      }
+      var isGenerator = eat(_star);
+      var isAsync = false;
+      parsePropertyName(method);
+      if (tokType !== _parenL && !method.computed && method.key.type === "Identifier" &&
+          method.key.name === "static") {
+        if (isGenerator || isAsync) unexpected();
+        method['static'] = true;
+        isGenerator = eat(_star);
+        parsePropertyName(method);
+      } else {
+        method['static'] = false;
+      }
+      if (tokType !== _parenL && !method.computed && method.key.type === "Identifier" &&
+          method.key.name === "async") {
+        isAsync = true;
+        parsePropertyName(method);
+      }
+      if (tokType !== _parenL && !method.computed && method.key.type === "Identifier" &&
+          (method.key.name === "get" || method.key.name === "set") || (options.playground && method.key.name === "memo")) {
+        if (isGenerator || isAsync) unexpected();
+        method.kind = method.key.name;
+        parsePropertyName(method);
+      } else {
+        method.kind = "";
+      }
+
+      var classProperty = false;
+
+      if (tokType === _colon) {
+        method.typeAnnotation = parseTypeAnnotation();
+        classProperty = true;
+      }
+
+      if (options.playground && eat(_eq)) {
+        method.value = parseMaybeAssign();
+        classProperty = true;
+      }
+
+      if (classProperty) {
+        semicolon();
+        classBody.body.push(finishNode(method, "ClassProperty"));
+      } else {
+        var typeParameters;
+        if (isRelational("<")) {
+          typeParameters = parseTypeParameterDeclaration();
+        }
+        method.value = parseMethod(isGenerator, isAsync);
+        method.value.typeParameters = typeParameters;
+        classBody.body.push(finishNode(method, "MethodDefinition"));
+        eat(_semi);
+      }
+    }
+    node.body = finishNode(classBody, "ClassBody");
+    return finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+  }
+
+  function parseClassImplements() {
+      var implemented = [];
+
+      do {
+        var node = startNode();
+        node.id = parseIdent();
+        if (isRelational("<")) {
+            node.typeParameters = parseTypeParameterInstantiation();
+        } else {
+            node.typeParameters = null;
+        }
+        implemented.push(finishNode(node, "ClassImplements"));
+      } while(eat(_comma));
+
+      return implemented;
+  }
+
+  // Parses a comma-separated list of expressions, and returns them as
+  // an array. `close` is the token type that ends the list, and
+  // `allowEmpty` can be turned on to allow subsequent commas with
+  // nothing in between them to be parsed as `null` (which is needed
+  // for array literals).
+
+  function parseExprList(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
+    var elts = [], first = true;
+    while (!eat(close)) {
+      if (!first) {
+        expect(_comma);
+        if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+      } else first = false;
+
+      if (allowEmpty && tokType === _comma) {
+        elts.push(null);
+      } else {
+        if (tokType === _ellipsis)
+          elts.push(parseSpread(refShorthandDefaultPos));
+        else
+          elts.push(parseMaybeAssign(false, refShorthandDefaultPos));
+      }
+    }
+    return elts;
+  }
+
+  // Parse the next token as an identifier. If `liberal` is true (used
+  // when parsing properties), it will also convert keywords into
+  // identifiers.
+
+  function parseIdent(liberal) {
+    var node = startNode();
+    if (liberal && options.forbidReserved == "everywhere") liberal = false;
+    if (tokType === _name) {
+      if (!liberal &&
+          (options.forbidReserved &&
+           (options.ecmaVersion === 3 ? isReservedWord3 : 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();
+    }
+    next();
+    return finishNode(node, "Identifier");
+  }
+
+  // Parses module export declaration.
+
+  function parseExport(node) {
+    next();
+    // export var|const|let|function|class ...;
+    if (tokType === _var || tokType === _const || tokType === _let || tokType === _function || tokType === _class || isContextual("async") || isContextual("type")) {
+      node.declaration = parseStatement(true);
+      node['default'] = false;
+      node.specifiers = null;
+      node.source = null;
+    } else
+    // export default ...;
+    if (eat(_default)) {
+      var expr = parseMaybeAssign();
+      if (expr.id) {
+        switch (expr.type) {
+          case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
+          case "ClassExpression": expr.type = "ClassDeclaration"; break;
+        }
+      }
+      node.declaration = expr;
+      node['default'] = true;
+      node.specifiers = null;
+      node.source = null;
+      semicolon();
+    } else {
+      // export * from '...';
+      // export { x, y as z } [from '...'];
+      var isBatch = tokType === _star;
+      node.declaration = null;
+      node['default'] = false;
+      node.specifiers = parseExportSpecifiers();
+      if (eatContextual("from")) {
+        node.source = tokType === _string ? parseExprAtom() : unexpected();
+      } else {
+        if (isBatch) unexpected();
+        node.source = null;
+      }
+      semicolon();
+    }
+    return finishNode(node, "ExportDeclaration");
+  }
+
+  // Parses a comma-separated list of module exports.
+
+  function parseExportSpecifiers() {
+    var nodes = [], first = true;
+    if (tokType === _star) {
+      // export * from '...'
+      var node = startNode();
+      next();
+      nodes.push(finishNode(node, "ExportBatchSpecifier"));
+    } else {
+      // export { x, y as z } [from '...']
+      expect(_braceL);
+      while (!eat(_braceR)) {
+        if (!first) {
+          expect(_comma);
+          if (options.allowTrailingCommas && eat(_braceR)) break;
+        } else first = false;
+
+        var node = startNode();
+        node.id = parseIdent(tokType === _default);
+        node.name = eatContextual("as") ? parseIdent(true) : null;
+        nodes.push(finishNode(node, "ExportSpecifier"));
+      }
+    }
+    return nodes;
+  }
+
+  // Parses import declaration.
+
+  function parseImport(node) {
+    next();
+    
+    node.isType = false;
+    node.specifiers = [];
+
+    var typeId;
+    if (isContextual('type')) {
+      var start = storeCurrentPos();
+      typeId = parseIdent();
+      if ((tokType === _name && tokVal !== "from") || tokType === _braceL || tokType === _star) {
+        node.isType = true;
+      } else {
+        node.specifiers.push(parseImportSpecifierDefault(typeId, start));
+        eat(_comma);
+      }
+    }
+
+    
+    // import '...';
+    if (tokType === _string) {
+      if (typeId) unexpected(typeId.start);
+      node.source = parseExprAtom();
+    } else {
+      if (!isContextual("from")) parseImportSpecifiers(node.specifiers);
+      expectContextual("from");
+      node.source = tokType === _string ? parseExprAtom() : unexpected();
+    }
+    semicolon();
+    return finishNode(node, "ImportDeclaration");
+  }
+
+  // Parses a comma-separated list of module imports.
+
+  function parseImportSpecifiers(nodes) {
+    var first = true;
+    if (tokType === _name) {
+      // import defaultObj, { x, y as z } from '...'
+      var start = storeCurrentPos();
+      var id = parseIdent();
+      nodes.push(parseImportSpecifierDefault(id, start));
+      if (!eat(_comma)) return nodes;
+    }
+    if (tokType === _star) {
+      var node = startNode();
+      next();
+      expectContextual("as");
+      node.name = parseIdent();
+      checkLVal(node.name, true);
+      nodes.push(finishNode(node, "ImportBatchSpecifier"));
+      return nodes;
+    }
+    expect(_braceL);
+    while (!eat(_braceR)) {
+      if (!first) {
+        expect(_comma);
+        if (options.allowTrailingCommas && eat(_braceR)) break;
+      } else first = false;
+
+      var node = startNode();
+      node.id = parseIdent(true);
+      node.name = eatContextual("as") ? parseIdent() : null;
+      checkLVal(node.name || node.id, true);
+      node['default'] = false;
+      nodes.push(finishNode(node, "ImportSpecifier"));
+    }
+    return nodes;
+  }
+
+  function parseImportSpecifierDefault(id, start) {
+    var node = startNodeAt(start);
+    node.id = id;
+    checkLVal(node.id, true);
+    node.name = null;
+    node['default'] = true;
+    return finishNode(node, "ImportSpecifier");
+  }
+
+  // Parses yield expression inside generator.
+
+  function parseYield() {
+    var node = startNode();
+    next();
+    if (eat(_semi) || canInsertSemicolon()) {
+      node.delegate = false;
+      node.argument = null;
+    } else {
+      node.delegate = eat(_star);
+      node.argument = parseMaybeAssign();
+    }
+    return finishNode(node, "YieldExpression");
+  }
+
+  // Parses await expression inside async function.
+
+  function parseAwait(node) {
+    if (eat(_semi) || canInsertSemicolon()) {
+      unexpected();
+    }
+    node.all = eat(_star);
+    node.argument = parseMaybeAssign(true);
+    return finishNode(node, "AwaitExpression");
+  }
+
+  // Parses array and generator comprehensions.
+
+  function parseComprehension(node, isGenerator) {
+    node.blocks = [];
+    while (tokType === _for) {
+      var block = startNode();
+      next();
+      expect(_parenL);
+      block.left = parseBindingAtom();
+      checkLVal(block.left, true);
+      expectContextual("of");
+      block.right = parseExpression();
+      expect(_parenR);
+      node.blocks.push(finishNode(block, "ComprehensionBlock"));
+    }
+    node.filter = eat(_if) ? parseParenExpression() : null;
+    node.body = parseExpression();
+    expect(isGenerator ? _parenR : _bracketR);
+    node.generator = isGenerator;
+    return finishNode(node, "ComprehensionExpression");
+  }
+
+  // Transforms JSX element name to string.
+
+  function getQualifiedJSXName(object) {
+    if (object.type === "JSXIdentifier") {
+      return object.name;
+    }
+    if (object.type === "JSXNamespacedName") {
+      return object.namespace.name + ':' + object.name.name;
+    }
+    if (object.type === "JSXMemberExpression") {
+      return (
+        getQualifiedJSXName(object.object) + '.' +
+        getQualifiedJSXName(object.property)
+      );
+    }
+  }
+
+  // Parse next token as JSX identifier
+
+  function parseJSXIdentifier() {
+    var node = startNode();
+    if (tokType === _jsxName) {
+      node.name = tokVal;
+    } else if (tokType.keyword) {
+      node.name = tokType.keyword;
+    } else {
+      unexpected();
+    }
+    next();
+    return finishNode(node, "JSXIdentifier");
+  }
+
+  // Parse namespaced identifier.
+
+  function parseJSXNamespacedName() {
+    var start = storeCurrentPos();
+    var name = parseJSXIdentifier();
+    if (!eat(_colon)) return name;
+    var node = startNodeAt(start);
+    node.namespace = name;
+    node.name = parseJSXIdentifier();
+    return finishNode(node, "JSXNamespacedName");
+  }
+
+  // Parses element name in any form - namespaced, member
+  // or single identifier.
+
+  function parseJSXElementName() {
+    var start = storeCurrentPos();
+    var node = parseJSXNamespacedName();
+    while (eat(_dot)) {
+      var newNode = startNodeAt(start);
+      newNode.object = node;
+      newNode.property = parseJSXIdentifier();
+      node = finishNode(newNode, "JSXMemberExpression");
+    }
+    return node;
+  }
+
+  // Parses any type of JSX attribute value.
+
+  function parseJSXAttributeValue() {
+    switch (tokType) {
+      case _braceL:
+        var node = parseJSXExpressionContainer();
+        if (node.expression.type === "JSXEmptyExpression") {
+          raise(
+            node.start,
+              'JSX attributes must only be assigned a non-empty ' +
+              'expression'
+          );
+        }
+        return node;
+
+      case _jsxTagStart:
+        return parseJSXElement();
+
+      case _jsxText:
+      case _string:
+        return parseExprAtom();
+
+      default:
+        raise(tokStart, "JSX value should be either an expression or a quoted JSX text");
+    }
+  }
+
+  // JSXEmptyExpression is unique type since it doesn't actually parse anything,
+  // and so it should start at the end of last read token (left brace) and finish
+  // at the beginning of the next one (right brace).
+
+  function parseJSXEmptyExpression() {
+    if (tokType !== _braceR) {
+      unexpected();
+    }
+
+    var tmp;
+
+    tmp = tokStart;
+    tokStart = lastEnd;
+    lastEnd = tmp;
+
+    tmp = tokStartLoc;
+    tokStartLoc = lastEndLoc;
+    lastEndLoc = tmp;
+
+    return finishNode(startNode(), "JSXEmptyExpression");
+  }
+
+  // Parses JSX expression enclosed into curly brackets.
+
+  function parseJSXExpressionContainer() {
+    var node = startNode();
+    next();
+    node.expression = tokType === _braceR ? parseJSXEmptyExpression() : parseExpression();
+    expect(_braceR);
+    return finishNode(node, "JSXExpressionContainer");
+  }
+
+  // Parses following JSX attribute name-value pair.
+
+  function parseJSXAttribute() {
+    var node = startNode();
+    if (eat(_braceL)) {
+      expect(_ellipsis);
+      node.argument = parseMaybeAssign();
+      expect(_braceR);
+      return finishNode(node, "JSXSpreadAttribute");
+    }
+    node.name = parseJSXNamespacedName();
+    node.value = eat(_eq) ? parseJSXAttributeValue() : null;
+    return finishNode(node, "JSXAttribute");
+  }
+
+  // Parses JSX opening tag starting after '<'.
+
+  function parseJSXOpeningElementAt(start) {
+    var node = startNodeAt(start);
+    node.attributes = [];
+    node.name = parseJSXElementName();
+    while (tokType !== _slash && tokType !== _jsxTagEnd) {
+      node.attributes.push(parseJSXAttribute());
+    }
+    node.selfClosing = eat(_slash);
+    expect(_jsxTagEnd);
+    return finishNode(node, "JSXOpeningElement");
+  }
+
+  // Parses JSX closing tag starting after '</'.
+
+  function parseJSXClosingElementAt(start) {
+    var node = startNodeAt(start);
+    node.name = parseJSXElementName();
+    expect(_jsxTagEnd);
+    return finishNode(node, "JSXClosingElement");
+  }
+
+  // Parses entire JSX element, including it's opening tag
+  // (starting after '<'), attributes, contents and closing tag.
+
+  function parseJSXElementAt(start) {
+    var node = startNodeAt(start);
+    var children = [];
+    var openingElement = parseJSXOpeningElementAt(start);
+    var closingElement = null;
+
+    if (!openingElement.selfClosing) {
+      contents:for (;;) {
+        switch (tokType) {
+          case _jsxTagStart:
+            start = storeCurrentPos();
+            next();
+            if (eat(_slash)) {
+              closingElement = parseJSXClosingElementAt(start);
+              break contents;
+            }
+            children.push(parseJSXElementAt(start));
+            break;
+
+          case _jsxText:
+            children.push(parseExprAtom());
+            break;
+
+          case _braceL:
+            children.push(parseJSXExpressionContainer());
+            break;
+
+          default:
+            unexpected();
+        }
+      }
+      if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
+        raise(
+          closingElement.start,
+          "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">"
+        );
+      }
+    }
+
+    node.openingElement = openingElement;
+    node.closingElement = closingElement;
+    node.children = children;
+    return finishNode(node, "JSXElement");
+  }
+
+  function isRelational(op) {
+    return tokType === _relational && tokVal === op;
+  }
+
+  function expectRelational(op) {
+    if (isRelational(op)) {
+      next();
+    } else {
+      unexpected();
+    }
+  }
+
+  // Parses entire JSX element from current position.
+
+  function parseJSXElement() {
+    var start = storeCurrentPos();
+    next();
+    return parseJSXElementAt(start);
+  }
+
+  // Declare
+  
+  function parseDeclareClass(node) {
+    next();
+    parseInterfaceish(node, true);
+    return finishNode(node, "DeclareClass");
+  }
+
+  function parseDeclareFunction(node) {
+    next();
+
+    var id = node.id = parseIdent();
+
+    var typeNode = startNode();
+    var typeContainer = startNode();
+
+    if (isRelational("<")) {
+      typeNode.typeParameters = parseTypeParameterDeclaration();
+    } else {
+      typeNode.typeParameters = null;
+    }
+
+    expect(_parenL);
+    var tmp = parseFunctionTypeParams();
+    typeNode.params = tmp.params;
+    typeNode.rest = tmp.rest;
+    expect(_parenR);
+
+    expect(_colon);
+    typeNode.returnType = parseType();
+
+    typeContainer.typeAnnotation = finishNode(typeNode, "FunctionTypeAnnotation");
+    id.typeAnnotation = finishNode(typeContainer, "TypeAnnotation");
+
+    finishNode(id, id.type);
+
+    semicolon();
+
+    return finishNode(node, "DeclareFunction");
+  }
+
+  function parseDeclare(node) {
+    if (tokType === _class) {
+      return parseDeclareClass(node);
+    } else if (tokType === _function) {
+      return parseDeclareFunction(node);
+    } else if (tokType === _var) {
+      return parseDeclareVariable(node);
+    } else if (isContextual("module")) {
+      return parseDeclareModule(node);
+    } else {
+      unexpected();
+    }
+  }
+
+  function parseDeclareVariable(node) {
+    next();
+    node.id = parseTypeAnnotatableIdentifier();
+    semicolon();
+    return finishNode(node, "DeclareVariable");
+  }
+
+  function parseDeclareModule(node) {
+    next();
+
+    if (tokType === _string) {
+      node.id = parseExprAtom();
+    } else {
+      node.id = parseIdent();
+    }
+
+    var bodyNode = node.body = startNode();
+    var body = bodyNode.body = [];
+    expect(_braceL);
+    while (tokType !== _braceR) {
+      var node2 = startNode();
+
+      // todo: declare check
+      next();
+
+      body.push(parseDeclare(node2));
+    }
+    expect(_braceR);
+
+    finishNode(bodyNode, "BlockStatement");
+    return finishNode(node, "DeclareModule");
+  }
+
+
+  // Interfaces
+
+  function parseInterfaceish(node, allowStatic) {
+    node.id = parseIdent();
+    
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterDeclaration();
+    } else {
+      node.typeParameters = null;
+    }
+
+    node.extends = [];
+
+    if (eat(_extends)) {
+      do {
+        node.extends.push(parseInterfaceExtends());
+      } while(eat(_comma));
+    }
+
+    node.body = parseObjectType(allowStatic);
+  }
+
+  function parseInterfaceExtends() {
+    var node = startNode();
+
+    node.id = parseIdent();
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterInstantiation();
+    } else {
+      node.typeParameters = null;
+    }
+
+    return finishNode(node, "InterfaceExtends");
+  }
+
+  function parseInterface(node) {
+    parseInterfaceish(node, false);
+    return finishNode(node, "InterfaceDeclaration");
+  }
+
+  // Type aliases
+  
+  function parseTypeAlias(node) {
+    node.id = parseIdent();
+
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterDeclaration();
+    } else {
+      node.typeParameters = null;
+    }
+
+    expect(_eq);
+
+    node.right = parseType();
+
+    semicolon();
+
+    return finishNode(node, "TypeAlias");
+  }
+
+  // Type annotations
+
+  function parseTypeParameterDeclaration() {
+    var node = startNode();
+    node.params = [];
+
+    expectRelational("<");
+    while (!isRelational(">")) {
+      node.params.push(parseIdent());
+      if (!isRelational(">")) {
+        expect(_comma);
+      }
+    }
+    expectRelational(">");
+
+    return finishNode(node, "TypeParameterDeclaration");
+  }
+
+  function parseTypeParameterInstantiation() {
+    var node = startNode(), oldInType = inType;
+    node.params = [];
+
+    inType = true;
+
+    expectRelational("<");
+    while (!isRelational(">")) {
+      node.params.push(parseType());
+      if (!isRelational(">")) {
+        expect(_comma);
+      }
+    }
+    expectRelational(">");
+
+    inType = oldInType;
+
+    return finishNode(node, "TypeParameterInstantiation");
+  }
+
+  function parseObjectPropertyKey() {
+    return (tokType === _num || tokType === _string) ? parseExprAtom() : parseIdent(true);
+  }
+
+  function parseObjectTypeIndexer(node, isStatic) {
+    node.static = isStatic;
+
+    expect(_bracketL);
+    node.id = parseObjectPropertyKey();
+    expect(_colon);
+    node.key = parseType();
+    expect(_bracketR);
+    expect(_colon);
+    node.value = parseType();
+
+    return finishNode(node, "ObjectTypeIndexer");
+  }
+
+  function parseObjectTypeMethodish(node) {
+    node.params = [];
+    node.rest = null;
+    node.typeParameters = null;
+
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterDeclaration();
+    }
+
+    expect(_parenL);
+    while (tokType === _name) {
+      node.params.push(parseFunctionTypeParam());
+      if (tokType !== _parenR) {
+        expect(_comma);
+      }
+    }
+
+    if (eat(_ellipsis)) {
+      node.rest = parseFunctionTypeParam();
+    }
+    expect(_parenR);
+    expect(_colon);
+    node.returnType = parseType();
+
+    return finishNode(node, "FunctionTypeAnnotation");
+  }
+
+  function parseObjectTypeMethod(start, isStatic, key) {
+    var node = startNodeAt(start);
+    node.value = parseObjectTypeMethodish(startNodeAt(start));
+    node.static = isStatic;
+    node.key = key;
+    node.optional = false;
+    return finishNode(node, "ObjectTypeProperty");
+  }
+
+  function parseObjectTypeCallProperty(node, isStatic) {
+    var valueNode = startNode();
+    node.static = isStatic;
+    node.value = parseObjectTypeMethodish(valueNode);
+    return finishNode(node, "ObjectTypeCallProperty");
+  }
+
+  function parseObjectType(allowStatic) {
+    var nodeStart = startNode();
+    var node;
+    var optional = false;
+    var property;
+    var propertyKey;
+    var propertyTypeAnnotation;
+    var token;
+    var isStatic;
+
+    nodeStart.callProperties = [];
+    nodeStart.properties = [];
+    nodeStart.indexers = [];
+
+    expect(_braceL);
+
+    while (tokType !== _braceR) {
+      var start = storeCurrentPos();
+      node = startNode();
+      if (allowStatic && isContextual("static")) {
+        next();
+        isStatic = true;
+      }
+
+      if (tokType === _bracketL) {
+        nodeStart.indexers.push(parseObjectTypeIndexer(node, isStatic));
+      } else if (tokType === _parenL || isRelational("<")) {
+        nodeStart.callProperties.push(parseObjectTypeCallProperty(node, allowStatic));
+      } else {
+        if (isStatic && tokType === _colon) {
+          propertyKey = parseIdent();
+        } else {
+          propertyKey = parseObjectPropertyKey();
+        }
+        if (isRelational("<") || tokType === _parenL) {
+          // This is a method property
+          nodeStart.properties.push(parseObjectTypeMethod(start, isStatic, propertyKey));
+        } else {
+          if (eat(_question)) {
+            optional = true;
+          }
+          expect(_colon);
+          node.key = propertyKey;
+          node.value = parseType();
+          node.optional = optional;
+          node.static = isStatic;
+          nodeStart.properties.push(finishNode(node, "ObjectTypeProperty"));
+        }
+      }
+
+      if (!eat(_semi) && tokType !== _braceR) {
+        unexpected();
+      }
+    }
+
+    expect(_braceR);
+
+    return finishNode(nodeStart, "ObjectTypeAnnotation")
+  }
+
+  function parseGenericType(start, id) {
+    var node = startNodeAt(start);
+
+    node.typeParameters = null;
+    node.id = id;
+
+    while (eat(_dot)) {
+      var node2 = startNodeAt(start);
+      node2.qualification = node.id;
+      node2.id = parseIdent();
+      node.id = finishNode(node2, "QualifiedTypeIdentifier");
+    }
+
+    if (isRelational("<")) {
+      node.typeParameters = parseTypeParameterInstantiation();
+    }
+
+    return finishNode(node, "GenericTypeAnnotation");
+  }
+
+  function parseVoidType() {
+    var node = startNode();
+    expect(keywordTypes["void"]);
+    return finishNode(node, "VoidTypeAnnotation");
+  }
+
+  function parseTypeofType() {
+    var node = startNode();
+    expect(keywordTypes["typeof"]);
+    node.argument = parsePrimaryType();
+    return finishNode(node, "TypeofTypeAnnotation");
+  }
+
+  function parseTupleType() {
+    var node = startNode();
+    node.types = [];
+    expect(_bracketL);
+    // We allow trailing commas
+    while (tokPos < inputLen && tokType !== _bracketR) {
+      node.types.push(parseType());
+      if (tokType === _bracketR) break;
+      expect(_comma);
+    }
+    expect(_bracketR);
+    return finishNode(node, "TupleTypeAnnotation");
+  }
+
+  function parseFunctionTypeParam() {
+    var optional = false;
+    var node = startNode();
+    node.name = parseIdent();
+    if (eat(_question)) {
+      optional = true;
+    }
+    expect(_colon);
+    node.optional = optional;
+    node.typeAnnotation = parseType();
+    return finishNode(node, "FunctionTypeParam");
+  }
+
+  function parseFunctionTypeParams() {
+    var ret = { params: [], rest: null };
+    while (tokType === _name) {
+      ret.params.push(parseFunctionTypeParam());
+      if (tokType !== _parenR) {
+        expect(_comma);
+      }
+    }
+
+    if (eat(_ellipsis)) {
+      ret.rest = parseFunctionTypeParam();
+    }
+    return ret;
+  }
+
+  function identToTypeAnnotation(start, node, id) {
+    switch (id.name) {
+      case 'any':
+        return finishNode(node, "AnyTypeAnnotation");
+
+      case 'bool':
+      case 'boolean':
+        return finishNode(node, "BooleanTypeAnnotation");
+
+      case 'number':
+        return finishNode(node, "NumberTypeAnnotation");
+
+      case 'string':
+        return finishNode(node, "StringTypeAnnotation");
+
+      default:
+        return parseGenericType(start, id);
+    }
+  }
+
+  // The parsing of types roughly parallels the parsing of expressions, and
+  // primary types are kind of like primary expressions...they're the
+  // primitives with which other types are constructed.
+  function parsePrimaryType() {
+    var typeIdentifier = null;
+    var params = null;
+    var returnType = null;
+    var start = storeCurrentPos();
+    var node = startNode();
+    var rest = null;
+    var tmp;
+    var typeParameters;
+    var token;
+    var type;
+    var isGroupedType = false;
+
+    switch (tokType) {
+      case _name:
+        return identToTypeAnnotation(start, node, parseIdent());
+
+      case _braceL:
+        return parseObjectType();
+
+      case _bracketL:
+        return parseTupleType();
+
+      case _relational:
+        if (tokVal === "<") {
+          node.typeParameters = parseTypeParameterDeclaration();
+          expect(_parenL);
+          tmp = parseFunctionTypeParams();
+          node.params = tmp.params;
+          node.rest = tmp.rest;
+          expect(_parenR);
+
+          expect(_arrow);
+
+          node.returnType = parseType();
+
+          return finishNode(node, "FunctionTypeAnnotation");
+        }
+
+      case _parenL:
+        next();
+
+        var tmpId;
+
+        // Check to see if this is actually a grouped type
+        if (tokType !== _parenR && tokType !== _ellipsis) {
+          if (tokType === _name) {
+            //raise(tokStart, "Grouped types are currently the only flow feature not supported, request it?");
+            //tmpId = identToTypeAnnotation(start, node, parseIdent());
+            //next();
+            //isGroupedType = tokType !== _question && tokType !== _colon;
+          } else {
+            isGroupedType = true;
+          }
+        }
+
+        if (isGroupedType) {
+          if (tmpId && _parenR) {
+            type = tmpId;
+          } else {
+            type = parseType();
+            expect(_parenR);
+          }
+
+          // If we see a => next then someone was probably confused about
+          // function types, so we can provide a better error message
+          if (eat(_arrow)) {
+            raise(node,
+              'Unexpected token =>. It looks like ' +
+              'you are trying to write a function type, but you ended up ' +
+              'writing a grouped type followed by an =>, which is a syntax ' +
+              'error. Remember, function type parameters are named so function ' +
+              'types look like (name1: type1, name2: type2) => returnType. You ' +
+              'probably wrote (type1) => returnType'
+            );
+          }
+
+          return type;
+        }
+
+        tmp = parseFunctionTypeParams();
+        node.params = tmp.params;
+        node.rest = tmp.rest;
+
+        expect(_parenR);
+
+        expect(_arrow);
+
+        node.returnType = parseType();
+        node.typeParameters = null;
+
+        return finishNode(node, "FunctionTypeAnnotation");
+
+      case _string:
+        node.value = tokVal;
+        node.raw = input.slice(tokStart, tokEnd);
+        next();
+        return finishNode(node, "StringLiteralTypeAnnotation");
+
+      default:
+        if (tokType.keyword) {
+          switch (tokType.keyword) {
+            case 'void':
+              return parseVoidType();
+
+            case 'typeof':
+              return parseTypeofType();
+          }
+        }
+    }
+
+    unexpected();
+  }
+
+  function parsePostfixType() {
+    var node = startNode();
+    var type = node.elementType = parsePrimaryType();
+    if (tokType === _bracketL) {
+      expect(_bracketL);
+      expect(_bracketR);
+      return finishNode(node, "ArrayTypeAnnotation");
+    }
+    return type;
+  }
+
+  function parsePrefixType() {
+    var node = startNode();
+    if (eat(_question)) {
+      node.typeAnnotation = parsePrefixType();
+      return finishNode(node, "NullableTypeAnnotation");
+    }
+    return parsePostfixType();
+  }
+
+  function parseIntersectionType() {
+    var node = startNode();
+    var type = parsePrefixType();
+    node.types = [type];
+    while (eat(_bitwiseAND)) {
+      node.types.push(parsePrefixType());
+    }
+    return node.types.length === 1 ? type : finishNode(node, "IntersectionTypeAnnotation");
+  }
+
+  function parseUnionType() {
+    var node = startNode();
+    var type = parseIntersectionType();
+    node.types = [type];
+    while (eat(_bitwiseOR)) {
+      node.types.push(parseIntersectionType());
+    }
+    return node.types.length === 1 ? type : finishNode(node, "UnionTypeAnnotation");
+  }
+
+  function parseType() {
+    var oldInType = inType;
+    inType = true;
+    var type = parseUnionType();
+    inType = oldInType;
+    return type;
+  }
+
+  function parseTypeAnnotation() {
+    var node = startNode();
+
+    var oldInType = inType;
+    inType = true;
+    expect(_colon);
+    node.typeAnnotation = parseType();
+    inType = oldInType;
+
+    return finishNode(node, "TypeAnnotation");
+  }
+
+  function parseTypeAnnotatableIdentifier(requireTypeAnnotation, canBeOptionalParam) {
+    var node = startNode();
+    var ident = parseIdent();
+    var isOptionalParam = false;
+
+    if (canBeOptionalParam && eat(_question)) {
+      expect(_question);
+      isOptionalParam = true;
+    }
+
+    if (requireTypeAnnotation || tokType === _colon) {
+      ident.typeAnnotation = parseTypeAnnotation();
+      finishNode(ident, ident.type);
+    }
+
+    if (isOptionalParam) {
+      ident.optional = true;
+      finishNode(ident, ident.type);
+    }
+
+    return ident;
+  }
+});
+
+},{}],123:[function(require,module,exports){
+var types = require("../lib/types");
+var Type = types.Type;
+var def = Type.def;
+var or = Type.or;
+var builtin = types.builtInTypes;
+var isString = builtin.string;
+var isNumber = builtin.number;
+var isBoolean = builtin.boolean;
+var isRegExp = builtin.RegExp;
+var shared = require("../lib/shared");
+var defaults = shared.defaults;
+var geq = shared.geq;
+
+// Abstract supertype of all syntactic entities that are allowed to have a
+// .loc field.
+def("Printable")
+    .field("loc", or(
+        def("SourceLocation"),
+        null
+    ), defaults["null"], true);
+
+def("Node")
+    .bases("Printable")
+    .field("type", isString)
+    .field("comments", or(
+        [def("Comment")],
+        null
+    ), defaults["null"], true);
+
+def("SourceLocation")
+    .build("start", "end", "source")
+    .field("start", def("Position"))
+    .field("end", def("Position"))
+    .field("source", or(isString, null), defaults["null"]);
+
+def("Position")
+    .build("line", "column")
+    .field("line", geq(1))
+    .field("column", geq(0));
+
+def("Program")
+    .bases("Node")
+    .build("body")
+    .field("body", [def("Statement")]);
+
+def("Function")
+    .bases("Node")
+    .field("id", or(def("Identifier"), null), defaults["null"])
+    .field("params", [def("Pattern")])
+    .field("body", or(def("BlockStatement"), def("Expression")));
+
+def("Statement").bases("Node");
+
+// The empty .build() here means that an EmptyStatement can be constructed
+// (i.e. it's not abstract) but that it needs no arguments.
+def("EmptyStatement").bases("Statement").build();
+
+def("BlockStatement")
+    .bases("Statement")
+    .build("body")
+    .field("body", [def("Statement")]);
+
+// TODO Figure out how to silently coerce Expressions to
+// ExpressionStatements where a Statement was expected.
+def("ExpressionStatement")
+    .bases("Statement")
+    .build("expression")
+    .field("expression", def("Expression"));
+
+def("IfStatement")
+    .bases("Statement")
+    .build("test", "consequent", "alternate")
+    .field("test", def("Expression"))
+    .field("consequent", def("Statement"))
+    .field("alternate", or(def("Statement"), null), defaults["null"]);
+
+def("LabeledStatement")
+    .bases("Statement")
+    .build("label", "body")
+    .field("label", def("Identifier"))
+    .field("body", def("Statement"));
+
+def("BreakStatement")
+    .bases("Statement")
+    .build("label")
+    .field("label", or(def("Identifier"), null), defaults["null"]);
+
+def("ContinueStatement")
+    .bases("Statement")
+    .build("label")
+    .field("label", or(def("Identifier"), null), defaults["null"]);
+
+def("WithStatement")
+    .bases("Statement")
+    .build("object", "body")
+    .field("object", def("Expression"))
+    .field("body", def("Statement"));
+
+def("SwitchStatement")
+    .bases("Statement")
+    .build("discriminant", "cases", "lexical")
+    .field("discriminant", def("Expression"))
+    .field("cases", [def("SwitchCase")])
+    .field("lexical", isBoolean, defaults["false"]);
+
+def("ReturnStatement")
+    .bases("Statement")
+    .build("argument")
+    .field("argument", or(def("Expression"), null));
+
+def("ThrowStatement")
+    .bases("Statement")
+    .build("argument")
+    .field("argument", def("Expression"));
+
+def("TryStatement")
+    .bases("Statement")
+    .build("block", "handler", "finalizer")
+    .field("block", def("BlockStatement"))
+    .field("handler", or(def("CatchClause"), null), function() {
+        return this.handlers && this.handlers[0] || null;
+    })
+    .field("handlers", [def("CatchClause")], function() {
+        return this.handler ? [this.handler] : [];
+    }, true) // Indicates this field is hidden from eachField iteration.
+    .field("guardedHandlers", [def("CatchClause")], defaults.emptyArray)
+    .field("finalizer", or(def("BlockStatement"), null), defaults["null"]);
+
+def("CatchClause")
+    .bases("Node")
+    .build("param", "guard", "body")
+    .field("param", def("Pattern"))
+    .field("guard", or(def("Expression"), null), defaults["null"])
+    .field("body", def("BlockStatement"));
+
+def("WhileStatement")
+    .bases("Statement")
+    .build("test", "body")
+    .field("test", def("Expression"))
+    .field("body", def("Statement"));
+
+def("DoWhileStatement")
+    .bases("Statement")
+    .build("body", "test")
+    .field("body", def("Statement"))
+    .field("test", def("Expression"));
+
+def("ForStatement")
+    .bases("Statement")
+    .build("init", "test", "update", "body")
+    .field("init", or(
+        def("VariableDeclaration"),
+        def("Expression"),
+        null))
+    .field("test", or(def("Expression"), null))
+    .field("update", or(def("Expression"), null))
+    .field("body", def("Statement"));
+
+def("ForInStatement")
+    .bases("Statement")
+    .build("left", "right", "body", "each")
+    .field("left", or(
+        def("VariableDeclaration"),
+        def("Expression")))
+    .field("right", def("Expression"))
+    .field("body", def("Statement"))
+    .field("each", isBoolean);
+
+def("DebuggerStatement").bases("Statement").build();
+
+def("Declaration").bases("Statement");
+
+def("FunctionDeclaration")
+    .bases("Function", "Declaration")
+    .build("id", "params", "body")
+    .field("id", def("Identifier"));
+
+def("FunctionExpression")
+    .bases("Function", "Expression")
+    .build("id", "params", "body");
+
+def("VariableDeclaration")
+    .bases("Declaration")
+    .build("kind", "declarations")
+    .field("kind", or("var", "let", "const"))
+    .field("declarations", [or(
+        def("VariableDeclarator"),
+        def("Identifier") // TODO Esprima deviation.
+    )]);
+
+def("VariableDeclarator")
+    .bases("Node")
+    .build("id", "init")
+    .field("id", def("Pattern"))
+    .field("init", or(def("Expression"), null));
+
+// TODO Are all Expressions really Patterns?
+def("Expression").bases("Node", "Pattern");
+
+def("ThisExpression").bases("Expression").build();
+
+def("ArrayExpression")
+    .bases("Expression")
+    .build("elements")
+    .field("elements", [or(def("Expression"), null)]);
+
+def("ObjectExpression")
+    .bases("Expression")
+    .build("properties")
+    .field("properties", [def("Property")]);
+
+// TODO Not in the Mozilla Parser API, but used by Esprima.
+def("Property")
+    .bases("Node") // Want to be able to visit Property Nodes.
+    .build("kind", "key", "value")
+    .field("kind", or("init", "get", "set"))
+    .field("key", or(def("Literal"), def("Identifier")))
+    // esprima allows Pattern
+    .field("value", or(def("Expression"), def("Pattern")));
+
+def("SequenceExpression")
+    .bases("Expression")
+    .build("expressions")
+    .field("expressions", [def("Expression")]);
+
+var UnaryOperator = or(
+    "-", "+", "!", "~",
+    "typeof", "void", "delete");
+
+def("UnaryExpression")
+    .bases("Expression")
+    .build("operator", "argument", "prefix")
+    .field("operator", UnaryOperator)
+    .field("argument", def("Expression"))
+    // TODO Esprima doesn't bother with this field, presumably because
+    // it's always true for unary operators.
+    .field("prefix", isBoolean, defaults["true"]);
+
+var BinaryOperator = or(
+    "==", "!=", "===", "!==",
+    "<", "<=", ">", ">=",
+    "<<", ">>", ">>>",
+    "+", "-", "*", "/", "%",
+    "&", // TODO Missing from the Parser API.
+    "|", "^", "in",
+    "instanceof", "..");
+
+def("BinaryExpression")
+    .bases("Expression")
+    .build("operator", "left", "right")
+    .field("operator", BinaryOperator)
+    .field("left", def("Expression"))
+    .field("right", def("Expression"));
+
+var AssignmentOperator = or(
+    "=", "+=", "-=", "*=", "/=", "%=",
+    "<<=", ">>=", ">>>=",
+    "|=", "^=", "&=");
+
+def("AssignmentExpression")
+    .bases("Expression")
+    .build("operator", "left", "right")
+    .field("operator", AssignmentOperator)
+    .field("left", def("Pattern"))
+    .field("right", def("Expression"));
+
+var UpdateOperator = or("++", "--");
+
+def("UpdateExpression")
+    .bases("Expression")
+    .build("operator", "argument", "prefix")
+    .field("operator", UpdateOperator)
+    .field("argument", def("Expression"))
+    .field("prefix", isBoolean);
+
+var LogicalOperator = or("||", "&&");
+
+def("LogicalExpression")
+    .bases("Expression")
+    .build("operator", "left", "right")
+    .field("operator", LogicalOperator)
+    .field("left", def("Expression"))
+    .field("right", def("Expression"));
+
+def("ConditionalExpression")
+    .bases("Expression")
+    .build("test", "consequent", "alternate")
+    .field("test", def("Expression"))
+    .field("consequent", def("Expression"))
+    .field("alternate", def("Expression"));
+
+def("NewExpression")
+    .bases("Expression")
+    .build("callee", "arguments")
+    .field("callee", def("Expression"))
+    // The Mozilla Parser API gives this type as [or(def("Expression"),
+    // null)], but null values don't really make sense at the call site.
+    // TODO Report this nonsense.
+    .field("arguments", [def("Expression")]);
+
+def("CallExpression")
+    .bases("Expression")
+    .build("callee", "arguments")
+    .field("callee", def("Expression"))
+    // See comment for NewExpression above.
+    .field("arguments", [def("Expression")]);
+
+def("MemberExpression")
+    .bases("Expression")
+    .build("object", "property", "computed")
+    .field("object", def("Expression"))
+    .field("property", or(def("Identifier"), def("Expression")))
+    .field("computed", isBoolean);
+
+def("Pattern").bases("Node");
+
+def("ObjectPattern")
+    .bases("Pattern")
+    .build("properties")
+    // TODO File a bug to get PropertyPattern added to the interfaces API.
+    // esprima uses Property
+    .field("properties", [or(def("PropertyPattern"), def("Property"))]);
+
+def("PropertyPattern")
+    .bases("Pattern")
+    .build("key", "pattern")
+    .field("key", or(def("Literal"), def("Identifier")))
+    .field("pattern", def("Pattern"));
+
+def("ArrayPattern")
+    .bases("Pattern")
+    .build("elements")
+    .field("elements", [or(def("Pattern"), null)]);
+
+def("SwitchCase")
+    .bases("Node")
+    .build("test", "consequent")
+    .field("test", or(def("Expression"), null))
+    .field("consequent", [def("Statement")]);
+
+def("Identifier")
+    // But aren't Expressions and Patterns already Nodes? TODO Report this.
+    .bases("Node", "Expression", "Pattern")
+    .build("name")
+    .field("name", isString);
+
+def("Literal")
+    // But aren't Expressions already Nodes? TODO Report this.
+    .bases("Node", "Expression")
+    .build("value")
+    .field("value", or(
+        isString,
+        isBoolean,
+        null, // isNull would also work here.
+        isNumber,
+        isRegExp
+    ));
+
+// Abstract (non-buildable) comment supertype. Not a Node.
+def("Comment")
+    .bases("Printable")
+    .field("value", isString)
+    // A .leading comment comes before the node, whereas a .trailing
+    // comment comes after it. These two fields should not both be true,
+    // but they might both be false when the comment falls inside a node
+    // and the node has no children for the comment to lead or trail,
+    // e.g. { /*dangling*/ }.
+    .field("leading", isBoolean, defaults["true"])
+    .field("trailing", isBoolean, defaults["false"]);
+
+// Block comment. The .type really should be BlockComment rather than
+// Block, but that's what we're stuck with for now.
+def("Block")
+    .bases("Comment")
+    .build("value", /*optional:*/ "leading", "trailing");
+
+// Single line comment. The .type really should be LineComment rather than
+// Line, but that's what we're stuck with for now.
+def("Line")
+    .bases("Comment")
+    .build("value", /*optional:*/ "leading", "trailing");
+
+},{"../lib/shared":134,"../lib/types":135}],124:[function(require,module,exports){
+require("./core");
+var types = require("../lib/types");
+var def = types.Type.def;
+var or = types.Type.or;
+var builtin = types.builtInTypes;
+var isString = builtin.string;
+var isBoolean = builtin.boolean;
+
+// Note that none of these types are buildable because the Mozilla Parser
+// API doesn't specify any builder functions, and nobody uses E4X anymore.
+
+def("XMLDefaultDeclaration")
+    .bases("Declaration")
+    .field("namespace", def("Expression"));
+
+def("XMLAnyName").bases("Expression");
+
+def("XMLQualifiedIdentifier")
+    .bases("Expression")
+    .field("left", or(def("Identifier"), def("XMLAnyName")))
+    .field("right", or(def("Identifier"), def("Expression")))
+    .field("computed", isBoolean);
+
+def("XMLFunctionQualifiedIdentifier")
+    .bases("Expression")
+    .field("right", or(def("Identifier"), def("Expression")))
+    .field("computed", isBoolean);
+
+def("XMLAttributeSelector")
+    .bases("Expression")
+    .field("attribute", def("Expression"));
+
+def("XMLFilterExpression")
+    .bases("Expression")
+    .field("left", def("Expression"))
+    .field("right", def("Expression"));
+
+def("XMLElement")
+    .bases("XML", "Expression")
+    .field("contents", [def("XML")]);
+
+def("XMLList")
+    .bases("XML", "Expression")
+    .field("contents", [def("XML")]);
+
+def("XML").bases("Node");
+
+def("XMLEscape")
+    .bases("XML")
+    .field("expression", def("Expression"));
+
+def("XMLText")
+    .bases("XML")
+    .field("text", isString);
+
+def("XMLStartTag")
+    .bases("XML")
+    .field("contents", [def("XML")]);
+
+def("XMLEndTag")
+    .bases("XML")
+    .field("contents", [def("XML")]);
+
+def("XMLPointTag")
+    .bases("XML")
+    .field("contents", [def("XML")]);
+
+def("XMLName")
+    .bases("XML")
+    .field("contents", or(isString, [def("XML")]));
+
+def("XMLAttribute")
+    .bases("XML")
+    .field("value", isString);
+
+def("XMLCdata")
+    .bases("XML")
+    .field("contents", isString);
+
+def("XMLComment")
+    .bases("XML")
+    .field("contents", isString);
+
+def("XMLProcessingInstruction")
+    .bases("XML")
+    .field("target", isString)
+    .field("contents", or(isString, null));
+
+},{"../lib/types":135,"./core":123}],125:[function(require,module,exports){
+require("./core");
+var types = require("../lib/types");
+var def = types.Type.def;
+var or = types.Type.or;
+var builtin = types.builtInTypes;
+var isBoolean = builtin.boolean;
+var isObject = builtin.object;
+var isString = builtin.string;
+var defaults = require("../lib/shared").defaults;
+
+def("Function")
+    .field("generator", isBoolean, defaults["false"])
+    .field("expression", isBoolean, defaults["false"])
+    .field("defaults", [or(def("Expression"), null)], defaults.emptyArray)
+    // TODO This could be represented as a SpreadElementPattern in .params.
+    .field("rest", or(def("Identifier"), null), defaults["null"]);
+
+def("FunctionDeclaration")
+    .build("id", "params", "body", "generator", "expression");
+
+def("FunctionExpression")
+    .build("id", "params", "body", "generator", "expression");
+
+// TODO The Parser API calls this ArrowExpression, but Esprima uses
+// ArrowFunctionExpression.
+def("ArrowFunctionExpression")
+    .bases("Function", "Expression")
+    .build("params", "body", "expression")
+    // The forced null value here is compatible with the overridden
+    // definition of the "id" field in the Function interface.
+    .field("id", null, defaults["null"])
+    // The current spec forbids arrow generators, so I have taken the
+    // liberty of enforcing that. TODO Report this.
+    .field("generator", false);
+
+def("YieldExpression")
+    .bases("Expression")
+    .build("argument", "delegate")
+    .field("argument", or(def("Expression"), null))
+    .field("delegate", isBoolean, defaults["false"]);
+
+def("GeneratorExpression")
+    .bases("Expression")
+    .build("body", "blocks", "filter")
+    .field("body", def("Expression"))
+    .field("blocks", [def("ComprehensionBlock")])
+    .field("filter", or(def("Expression"), null));
+
+def("ComprehensionExpression")
+    .bases("Expression")
+    .build("body", "blocks", "filter")
+    .field("body", def("Expression"))
+    .field("blocks", [def("ComprehensionBlock")])
+    .field("filter", or(def("Expression"), null));
+
+def("ComprehensionBlock")
+    .bases("Node")
+    .build("left", "right", "each")
+    .field("left", def("Pattern"))
+    .field("right", def("Expression"))
+    .field("each", isBoolean);
+
+def("ModuleSpecifier")
+    .bases("Literal")
+    .build("value")
+    .field("value", isString);
+
+def("Property")
+    // Esprima extensions not mentioned in the Mozilla Parser API:
+    .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+    .field("method", isBoolean, defaults["false"])
+    .field("shorthand", isBoolean, defaults["false"])
+    .field("computed", isBoolean, defaults["false"]);
+
+def("PropertyPattern")
+    .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+    .field("computed", isBoolean, defaults["false"]);
+
+def("MethodDefinition")
+    .bases("Declaration")
+    .build("kind", "key", "value")
+    .field("kind", or("init", "get", "set", ""))
+    .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+    .field("value", def("Function"))
+    .field("computed", isBoolean, defaults["false"]);
+
+def("SpreadElement")
+    .bases("Node")
+    .build("argument")
+    .field("argument", def("Expression"));
+
+def("ArrayExpression")
+    .field("elements", [or(def("Expression"), def("SpreadElement"), null)]);
+
+def("NewExpression")
+    .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
+
+def("CallExpression")
+    .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
+
+def("SpreadElementPattern")
+    .bases("Pattern")
+    .build("argument")
+    .field("argument", def("Pattern"));
+
+def("ArrayPattern")
+    .field("elements", [or(
+        def("Pattern"),
+        null,
+        // used by esprima
+        def("SpreadElement")
+    )]);
+
+var ClassBodyElement = or(
+    def("MethodDefinition"),
+    def("VariableDeclarator"),
+    def("ClassPropertyDefinition"),
+    def("ClassProperty")
+);
+
+def("ClassProperty")
+  .bases("Declaration")
+  .build("key")
+  .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+  .field("computed", isBoolean, defaults["false"]);
+
+def("ClassPropertyDefinition") // static property
+    .bases("Declaration")
+    .build("definition")
+    // Yes, Virginia, circular definitions are permitted.
+    .field("definition", ClassBodyElement);
+
+def("ClassBody")
+    .bases("Declaration")
+    .build("body")
+    .field("body", [ClassBodyElement]);
+
+def("ClassDeclaration")
+    .bases("Declaration")
+    .build("id", "body", "superClass")
+    .field("id", def("Identifier"))
+    .field("body", def("ClassBody"))
+    .field("superClass", or(def("Expression"), null), defaults["null"]);
+
+def("ClassExpression")
+    .bases("Expression")
+    .build("id", "body", "superClass")
+    .field("id", or(def("Identifier"), null), defaults["null"])
+    .field("body", def("ClassBody"))
+    .field("superClass", or(def("Expression"), null), defaults["null"])
+    .field("implements", [def("ClassImplements")], defaults.emptyArray);
+
+def("ClassImplements")
+    .bases("Node")
+    .build("id")
+    .field("id", def("Identifier"))
+    .field("superClass", or(def("Expression"), null), defaults["null"]);
+
+// Specifier and NamedSpecifier are abstract non-standard types that I
+// introduced for definitional convenience.
+def("Specifier").bases("Node");
+def("NamedSpecifier")
+    .bases("Specifier")
+    // Note: this abstract type is intentionally not buildable.
+    .field("id", def("Identifier"))
+    .field("name", or(def("Identifier"), null), defaults["null"]);
+
+// Like NamedSpecifier, except type:"ExportSpecifier" and buildable.
+// export {<id [as name]>} [from ...];
+def("ExportSpecifier")
+    .bases("NamedSpecifier")
+    .build("id", "name");
+
+// export <*> from ...;
+def("ExportBatchSpecifier")
+    .bases("Specifier")
+    .build();
+
+// Like NamedSpecifier, except type:"ImportSpecifier" and buildable.
+// import {<id [as name]>} from ...;
+def("ImportSpecifier")
+    .bases("NamedSpecifier")
+    .build("id", "name");
+
+// import <* as id> from ...;
+def("ImportNamespaceSpecifier")
+    .bases("Specifier")
+    .build("id")
+    .field("id", def("Identifier"));
+
+// import <id> from ...;
+def("ImportDefaultSpecifier")
+    .bases("Specifier")
+    .build("id")
+    .field("id", def("Identifier"));
+
+def("ExportDeclaration")
+    .bases("Declaration")
+    .build("default", "declaration", "specifiers", "source")
+    .field("default", isBoolean)
+    .field("declaration", or(
+        def("Declaration"),
+        def("Expression"), // Implies default.
+        null
+    ))
+    .field("specifiers", [or(
+        def("ExportSpecifier"),
+        def("ExportBatchSpecifier")
+    )], defaults.emptyArray)
+    .field("source", or(def("ModuleSpecifier"), null), defaults["null"]);
+
+def("ImportDeclaration")
+    .bases("Declaration")
+    .build("specifiers", "source")
+    .field("specifiers", [or(
+        def("ImportSpecifier"),
+        def("ImportNamespaceSpecifier"),
+        def("ImportDefaultSpecifier")
+    )], defaults.emptyArray)
+    .field("source", def("ModuleSpecifier"));
+
+def("TaggedTemplateExpression")
+    .bases("Expression")
+    .field("tag", def("Expression"))
+    .field("quasi", def("TemplateLiteral"));
+
+def("TemplateLiteral")
+    .bases("Expression")
+    .build("quasis", "expressions")
+    .field("quasis", [def("TemplateElement")])
+    .field("expressions", [def("Expression")]);
+
+def("TemplateElement")
+    .bases("Node")
+    .build("value", "tail")
+    .field("value", {"cooked": isString, "raw": isString})
+    .field("tail", isBoolean);
+
+},{"../lib/shared":134,"../lib/types":135,"./core":123}],126:[function(require,module,exports){
+require("./core");
+var types = require("../lib/types");
+var def = types.Type.def;
+var or = types.Type.or;
+var builtin = types.builtInTypes;
+var isBoolean = builtin.boolean;
+var defaults = require("../lib/shared").defaults;
+
+def("Function")
+    .field("async", isBoolean, defaults["false"]);
+
+def("SpreadProperty")
+    .bases("Node")
+    .build("argument")
+    .field("argument", def("Expression"));
+
+def("ObjectExpression")
+    .field("properties", [or(def("Property"), def("SpreadProperty"))]);
+
+def("SpreadPropertyPattern")
+    .bases("Pattern")
+    .build("argument")
+    .field("argument", def("Pattern"));
+
+def("ObjectPattern")
+    .field("properties", [or(
+        def("PropertyPattern"),
+        def("SpreadPropertyPattern"),
+        // used by esprima
+        def("Property"),
+        def("SpreadProperty")
+    )]);
+
+def("AwaitExpression")
+    .bases("Expression")
+    .build("argument", "all")
+    .field("argument", or(def("Expression"), null))
+    .field("all", isBoolean, defaults["false"]);
+
+},{"../lib/shared":134,"../lib/types":135,"./core":123}],127:[function(require,module,exports){
+require("./core");
+var types = require("../lib/types");
+var def = types.Type.def;
+var or = types.Type.or;
+var builtin = types.builtInTypes;
+var isString = builtin.string;
+var isBoolean = builtin.boolean;
+var defaults = require("../lib/shared").defaults;
+
+def("XJSAttribute")
+    .bases("Node")
+    .build("name", "value")
+    .field("name", or(def("XJSIdentifier"), def("XJSNamespacedName")))
+    .field("value", or(
+        def("Literal"), // attr="value"
+        def("XJSExpressionContainer"), // attr={value}
+        null // attr= or just attr
+    ), defaults["null"]);
+
+def("XJSIdentifier")
+    .bases("Node")
+    .build("name")
+    .field("name", isString);
+
+def("XJSNamespacedName")
+    .bases("Node")
+    .build("namespace", "name")
+    .field("namespace", def("XJSIdentifier"))
+    .field("name", def("XJSIdentifier"));
+
+def("XJSMemberExpression")
+    .bases("MemberExpression")
+    .build("object", "property")
+    .field("object", or(def("XJSIdentifier"), def("XJSMemberExpression")))
+    .field("property", def("XJSIdentifier"))
+    .field("computed", isBoolean, defaults.false);
+
+var XJSElementName = or(
+    def("XJSIdentifier"),
+    def("XJSNamespacedName"),
+    def("XJSMemberExpression")
+);
+
+def("XJSSpreadAttribute")
+    .bases("Node")
+    .build("argument")
+    .field("argument", def("Expression"));
+
+var XJSAttributes = [or(
+    def("XJSAttribute"),
+    def("XJSSpreadAttribute")
+)];
+
+def("XJSExpressionContainer")
+    .bases("Expression")
+    .build("expression")
+    .field("expression", def("Expression"));
+
+def("XJSElement")
+    .bases("Expression")
+    .build("openingElement", "closingElement", "children")
+    .field("openingElement", def("XJSOpeningElement"))
+    .field("closingElement", or(def("XJSClosingElement"), null), defaults["null"])
+    .field("children", [or(
+        def("XJSElement"),
+        def("XJSExpressionContainer"),
+        def("XJSText"),
+        def("Literal") // TODO Esprima should return XJSText instead.
+    )], defaults.emptyArray)
+    .field("name", XJSElementName, function() {
+        // Little-known fact: the `this` object inside a default function
+        // is none other than the partially-built object itself, and any
+        // fields initialized directly from builder function arguments
+        // (like openingElement, closingElement, and children) are
+        // guaranteed to be available.
+        return this.openingElement.name;
+    })
+    .field("selfClosing", isBoolean, function() {
+        return this.openingElement.selfClosing;
+    })
+    .field("attributes", XJSAttributes, function() {
+        return this.openingElement.attributes;
+    });
+
+def("XJSOpeningElement")
+    .bases("Node") // TODO Does this make sense? Can't really be an XJSElement.
+    .build("name", "attributes", "selfClosing")
+    .field("name", XJSElementName)
+    .field("attributes", XJSAttributes, defaults.emptyArray)
+    .field("selfClosing", isBoolean, defaults["false"]);
+
+def("XJSClosingElement")
+    .bases("Node") // TODO Same concern.
+    .build("name")
+    .field("name", XJSElementName);
+
+def("XJSText")
+    .bases("Literal")
+    .build("value")
+    .field("value", isString);
+
+def("XJSEmptyExpression").bases("Expression").build();
+
+// Type Annotations
+def("Type")
+  .bases("Node");
+
+def("AnyTypeAnnotation")
+  .bases("Type");
+
+def("VoidTypeAnnotation")
+  .bases("Type");
+
+def("NumberTypeAnnotation")
+  .bases("Type");
+
+def("StringTypeAnnotation")
+  .bases("Type");
+
+def("StringLiteralTypeAnnotation")
+  .bases("Type")
+  .build("value", "raw")
+  .field("value", isString)
+  .field("raw", isString);
+
+def("BooleanTypeAnnotation")
+  .bases("Type");
+
+def("TypeAnnotation")
+  .bases("Node")
+  .build("typeAnnotation")
+  .field("typeAnnotation", def("Type"));
+
+def("NullableTypeAnnotation")
+  .bases("Type")
+  .build("typeAnnotation")
+  .field("typeAnnotation", def("Type"));
+
+def("FunctionTypeAnnotation")
+  .bases("Type")
+  .build("params", "returnType", "rest", "typeParameters")
+  .field("params", [def("FunctionTypeParam")])
+  .field("returnType", def("Type"))
+  .field("rest", or(def("FunctionTypeParam"), null))
+  .field("typeParameters", or(def("TypeParameterDeclaration"), null));
+
+def("FunctionTypeParam")
+  .bases("Node")
+  .build("name", "typeAnnotation", "optional")
+  .field("name", def("Identifier"))
+  .field("typeAnnotation", def("Type"))
+  .field("optional", isBoolean);
+  
+def("ArrayTypeAnnotation")
+  .bases("Type")
+  .build("elementType")
+  .field("elementType", def("Type"));
+
+def("ObjectTypeAnnotation")
+  .bases("Type")
+  .build("properties")
+  .field("properties", [def("ObjectTypeProperty")])
+  .field("indexers", [def("ObjectTypeIndexer")], defaults.emptyArray)
+  .field("callProperties", [def("ObjectTypeCallProperty")], defaults.emptyArray);
+
+def("ObjectTypeProperty")
+  .bases("Node")
+  .build("key", "value", "optional")
+  .field("key", or(def("Literal"), def("Identifier")))
+  .field("value", def("Type"))
+  .field("optional", isBoolean);
+
+def("ObjectTypeIndexer")
+  .bases("Node")
+  .build("id", "key", "value")
+  .field("id", def("Identifier"))
+  .field("key", def("Type"))
+  .field("value", def("Type"));
+
+def("ObjectTypeCallProperty")
+  .bases("Node")
+  .build("value")
+  .field("value", def("FunctionTypeAnnotation"))
+  .field("static", isBoolean, false);
+
+def("QualifiedTypeIdentifier")
+  .bases("Node")
+  .build("qualification", "id")
+  .field("qualification", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+  .field("id", def("Identifier"));
+
+def("GenericTypeAnnotation")
+  .bases("Type")
+  .build("id", "typeParameters")
+  .field("id", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+  .field("typeParameters", or(def("TypeParameterInstantiation"), null));
+
+def("MemberTypeAnnotation")
+  .bases("Type")
+  .build("object", "property")
+  .field("object", def("Identifier"))
+  .field("property", or(def("MemberTypeAnnotation"), def("GenericTypeAnnotation")));
+
+def("UnionTypeAnnotation")
+  .bases("Type")
+  .build("types")
+  .field("types", [def("Type")]);
+
+def("IntersectionTypeAnnotation")
+  .bases("Type")
+  .build("types")
+  .field("types", [def("Type")]);
+
+def("TypeofTypeAnnotation")
+  .bases("Type")
+  .build("argument")
+  .field("argument", def("Type"));
+
+def("Identifier")
+  .field("typeAnnotation", or(def("TypeAnnotation"), null), defaults["null"]);
+
+def("TypeParameterDeclaration")
+  .bases("Node")
+  .build("params")
+  .field("params", [def("Identifier")]);
+
+def("TypeParameterInstantiation")
+  .bases("Node")
+  .build("params")
+  .field("params", [def("Type")]);
+
+def("Function")
+  .field("returnType", or(def("TypeAnnotation"), null), defaults["null"])
+  .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"]);
+
+def("ClassProperty")
+  .build("key", "typeAnnotation")
+  .field("typeAnnotation", def("TypeAnnotation"))
+  .field("static", isBoolean, false);
+
+def("ClassImplements")
+  .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
+
+def("InterfaceDeclaration")
+  .bases("Statement")
+  .build("id", "body", "extends")
+  .field("id", def("Identifier"))
+  .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"])
+  .field("body", def("ObjectTypeAnnotation"))
+  .field("extends", [def("InterfaceExtends")]);
+
+def("InterfaceExtends")
+  .bases("Node")
+  .build("id")
+  .field("id", def("Identifier"))
+  .field("typeParameters", or(def("TypeParameterInstantiation"), null));
+
+def("TypeAlias")
+  .bases("Statement")
+  .build("id", "typeParameters", "right")
+  .field("id", def("Identifier"))
+  .field("typeParameters", or(def("TypeParameterDeclaration"), null))
+  .field("right", def("Type"));
+  
+def("TypeCastExpression")
+  .bases("Expression")
+  .build("expression", "typeAnnotation")
+  .field("expression", def("Expression"))
+  .field("typeAnnotation", def("TypeAnnotation"));
+
+def("TupleTypeAnnotation")
+  .bases("Type")
+  .build("types")
+  .field("types", [def("Type")]);
+
+def("DeclareVariable")
+  .bases("Statement")
+  .build("id")
+  .field("id", def("Identifier"));
+
+def("DeclareFunction")
+  .bases("Statement")
+  .build("id")
+  .field("id", def("Identifier"));
+
+def("DeclareClass")
+  .bases("InterfaceDeclaration")
+  .build("id");
+
+def("DeclareModule")
+  .bases("Statement")
+  .build("id", "body")
+  .field("id", or(def("Identifier"), def("Literal")))
+  .field("body", def("BlockStatement"));
+
+},{"../lib/shared":134,"../lib/types":135,"./core":123}],128:[function(require,module,exports){
+require("./core");
+var types = require("../lib/types");
+var def = types.Type.def;
+var or = types.Type.or;
+var geq = require("../lib/shared").geq;
+
+def("ForOfStatement")
+    .bases("Statement")
+    .build("left", "right", "body")
+    .field("left", or(
+        def("VariableDeclaration"),
+        def("Expression")))
+    .field("right", def("Expression"))
+    .field("body", def("Statement"));
+
+def("LetStatement")
+    .bases("Statement")
+    .build("head", "body")
+    // TODO Deviating from the spec by reusing VariableDeclarator here.
+    .field("head", [def("VariableDeclarator")])
+    .field("body", def("Statement"));
+
+def("LetExpression")
+    .bases("Expression")
+    .build("head", "body")
+    // TODO Deviating from the spec by reusing VariableDeclarator here.
+    .field("head", [def("VariableDeclarator")])
+    .field("body", def("Expression"));
+
+def("GraphExpression")
+    .bases("Expression")
+    .build("index", "expression")
+    .field("index", geq(0))
+    .field("expression", def("Literal"));
+
+def("GraphIndexExpression")
+    .bases("Expression")
+    .build("index")
+    .field("index", geq(0));
+
+},{"../lib/shared":134,"../lib/types":135,"./core":123}],129:[function(require,module,exports){
+var assert = require("assert");
+var types = require("../main");
+var getFieldNames = types.getFieldNames;
+var getFieldValue = types.getFieldValue;
+var isArray = types.builtInTypes.array;
+var isObject = types.builtInTypes.object;
+var isDate = types.builtInTypes.Date;
+var isRegExp = types.builtInTypes.RegExp;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function astNodesAreEquivalent(a, b, problemPath) {
+    if (isArray.check(problemPath)) {
+        problemPath.length = 0;
+    } else {
+        problemPath = null;
+    }
+
+    return areEquivalent(a, b, problemPath);
+}
+
+astNodesAreEquivalent.assert = function(a, b) {
+    var problemPath = [];
+    if (!astNodesAreEquivalent(a, b, problemPath)) {
+        if (problemPath.length === 0) {
+            assert.strictEqual(a, b);
+        } else {
+            assert.ok(
+                false,
+                "Nodes differ in the following path: " +
+                    problemPath.map(subscriptForProperty).join("")
+            );
+        }
+    }
+};
+
+function subscriptForProperty(property) {
+    if (/[_$a-z][_$a-z0-9]*/i.test(property)) {
+        return "." + property;
+    }
+    return "[" + JSON.stringify(property) + "]";
+}
+
+function areEquivalent(a, b, problemPath) {
+    if (a === b) {
+        return true;
+    }
+
+    if (isArray.check(a)) {
+        return arraysAreEquivalent(a, b, problemPath);
+    }
+
+    if (isObject.check(a)) {
+        return objectsAreEquivalent(a, b, problemPath);
+    }
+
+    if (isDate.check(a)) {
+        return isDate.check(b) && (+a === +b);
+    }
+
+    if (isRegExp.check(a)) {
+        return isRegExp.check(b) && (
+            a.source === b.source &&
+            a.global === b.global &&
+            a.multiline === b.multiline &&
+            a.ignoreCase === b.ignoreCase
+        );
+    }
+
+    return a == b;
+}
+
+function arraysAreEquivalent(a, b, problemPath) {
+    isArray.assert(a);
+    var aLength = a.length;
+
+    if (!isArray.check(b) || b.length !== aLength) {
+        if (problemPath) {
+            problemPath.push("length");
+        }
+        return false;
+    }
+
+    for (var i = 0; i < aLength; ++i) {
+        if (problemPath) {
+            problemPath.push(i);
+        }
+
+        if (i in a !== i in b) {
+            return false;
+        }
+
+        if (!areEquivalent(a[i], b[i], problemPath)) {
+            return false;
+        }
+
+        if (problemPath) {
+            assert.strictEqual(problemPath.pop(), i);
+        }
+    }
+
+    return true;
+}
+
+function objectsAreEquivalent(a, b, problemPath) {
+    isObject.assert(a);
+    if (!isObject.check(b)) {
+        return false;
+    }
+
+    // Fast path for a common property of AST nodes.
+    if (a.type !== b.type) {
+        if (problemPath) {
+            problemPath.push("type");
+        }
+        return false;
+    }
+
+    var aNames = getFieldNames(a);
+    var aNameCount = aNames.length;
+
+    var bNames = getFieldNames(b);
+    var bNameCount = bNames.length;
+
+    if (aNameCount === bNameCount) {
+        for (var i = 0; i < aNameCount; ++i) {
+            var name = aNames[i];
+            var aChild = getFieldValue(a, name);
+            var bChild = getFieldValue(b, name);
+
+            if (problemPath) {
+                problemPath.push(name);
+            }
+
+            if (!areEquivalent(aChild, bChild, problemPath)) {
+                return false;
+            }
+
+            if (problemPath) {
+                assert.strictEqual(problemPath.pop(), name);
+            }
+        }
+
+        return true;
+    }
+
+    if (!problemPath) {
+        return false;
+    }
+
+    // Since aNameCount !== bNameCount, we need to find some name that's
+    // missing in aNames but present in bNames, or vice-versa.
+
+    var seenNames = Object.create(null);
+
+    for (i = 0; i < aNameCount; ++i) {
+        seenNames[aNames[i]] = true;
+    }
+
+    for (i = 0; i < bNameCount; ++i) {
+        name = bNames[i];
+
+        if (!hasOwn.call(seenNames, name)) {
+            problemPath.push(name);
+            return false;
+        }
+
+        delete seenNames[name];
+    }
+
+    for (name in seenNames) {
+        problemPath.push(name);
+        break;
+    }
+
+    return false;
+}
+
+module.exports = astNodesAreEquivalent;
+
+},{"../main":136,"assert":138}],130:[function(require,module,exports){
+var assert = require("assert");
+var types = require("./types");
+var n = types.namedTypes;
+var b = types.builders;
+var isNumber = types.builtInTypes.number;
+var isArray = types.builtInTypes.array;
+var Path = require("./path");
+var Scope = require("./scope");
+
+function NodePath(value, parentPath, name) {
+    assert.ok(this instanceof NodePath);
+    Path.call(this, value, parentPath, name);
+}
+
+require("util").inherits(NodePath, Path);
+var NPp = NodePath.prototype;
+
+Object.defineProperties(NPp, {
+    node: {
+        get: function() {
+            Object.defineProperty(this, "node", {
+                configurable: true, // Enable deletion.
+                value: this._computeNode()
+            });
+
+            return this.node;
+        }
+    },
+
+    parent: {
+        get: function() {
+            Object.defineProperty(this, "parent", {
+                configurable: true, // Enable deletion.
+                value: this._computeParent()
+            });
+
+            return this.parent;
+        }
+    },
+
+    scope: {
+        get: function() {
+            Object.defineProperty(this, "scope", {
+                configurable: true, // Enable deletion.
+                value: this._computeScope()
+            });
+
+            return this.scope;
+        }
+    }
+});
+
+NPp.replace = function() {
+    delete this.node;
+    delete this.parent;
+    delete this.scope;
+    return Path.prototype.replace.apply(this, arguments);
+};
+
+NPp.prune = function() {
+    var remainingNodePath = this.parent;
+
+    this.replace();
+
+    return cleanUpNodesAfterPrune(remainingNodePath);
+};
+
+// The value of the first ancestor Path whose value is a Node.
+NPp._computeNode = function() {
+    var value = this.value;
+    if (n.Node.check(value)) {
+        return value;
+    }
+
+    var pp = this.parentPath;
+    return pp && pp.node || null;
+};
+
+// The first ancestor Path whose value is a Node distinct from this.node.
+NPp._computeParent = function() {
+    var value = this.value;
+    var pp = this.parentPath;
+
+    if (!n.Node.check(value)) {
+        while (pp && !n.Node.check(pp.value)) {
+            pp = pp.parentPath;
+        }
+
+        if (pp) {
+            pp = pp.parentPath;
+        }
+    }
+
+    while (pp && !n.Node.check(pp.value)) {
+        pp = pp.parentPath;
+    }
+
+    return pp || null;
+};
+
+// The closest enclosing scope that governs this node.
+NPp._computeScope = function() {
+    var value = this.value;
+    var pp = this.parentPath;
+    var scope = pp && pp.scope;
+
+    if (n.Node.check(value) &&
+        Scope.isEstablishedBy(value)) {
+        scope = new Scope(this, scope);
+    }
+
+    return scope || null;
+};
+
+NPp.getValueProperty = function(name) {
+    return types.getFieldValue(this.value, name);
+};
+
+/**
+ * Determine whether this.node needs to be wrapped in parentheses in order
+ * for a parser to reproduce the same local AST structure.
+ *
+ * For instance, in the expression `(1 + 2) * 3`, the BinaryExpression
+ * whose operator is "+" needs parentheses, because `1 + 2 * 3` would
+ * parse differently.
+ *
+ * If assumeExpressionContext === true, we don't worry about edge cases
+ * like an anonymous FunctionExpression appearing lexically first in its
+ * enclosing statement and thus needing parentheses to avoid being parsed
+ * as a FunctionDeclaration with a missing name.
+ */
+NPp.needsParens = function(assumeExpressionContext) {
+    var pp = this.parentPath;
+    if (!pp) {
+        return false;
+    }
+
+    var node = this.value;
+
+    // Only expressions need parentheses.
+    if (!n.Expression.check(node)) {
+        return false;
+    }
+
+    // Identifiers never need parentheses.
+    if (node.type === "Identifier") {
+        return false;
+    }
+
+    while (!n.Node.check(pp.value)) {
+        pp = pp.parentPath;
+        if (!pp) {
+            return false;
+        }
+    }
+
+    var parent = pp.value;
+
+    switch (node.type) {
+    case "UnaryExpression":
+    case "SpreadElement":
+    case "SpreadProperty":
+        return parent.type === "MemberExpression"
+            && this.name === "object"
+            && parent.object === node;
+
+    case "BinaryExpression":
+    case "LogicalExpression":
+        switch (parent.type) {
+        case "CallExpression":
+            return this.name === "callee"
+                && parent.callee === node;
+
+        case "UnaryExpression":
+        case "SpreadElement":
+        case "SpreadProperty":
+            return true;
+
+        case "MemberExpression":
+            return this.name === "object"
+                && parent.object === node;
+
+        case "BinaryExpression":
+        case "LogicalExpression":
+            var po = parent.operator;
+            var pp = PRECEDENCE[po];
+            var no = node.operator;
+            var np = PRECEDENCE[no];
+
+            if (pp > np) {
+                return true;
+            }
+
+            if (pp === np && this.name === "right") {
+                assert.strictEqual(parent.right, node);
+                return true;
+            }
+
+        default:
+            return false;
+        }
+
+    case "SequenceExpression":
+        switch (parent.type) {
+        case "ForStatement":
+            // Although parentheses wouldn't hurt around sequence
+            // expressions in the head of for loops, traditional style
+            // dictates that e.g. i++, j++ should not be wrapped with
+            // parentheses.
+            return false;
+
+        case "ExpressionStatement":
+            return this.name !== "expression";
+
+        default:
+            // Otherwise err on the side of overparenthesization, adding
+            // explicit exceptions above if this proves overzealous.
+            return true;
+        }
+
+    case "YieldExpression":
+        switch (parent.type) {
+        case "BinaryExpression":
+        case "LogicalExpression":
+        case "UnaryExpression":
+        case "SpreadElement":
+        case "SpreadProperty":
+        case "CallExpression":
+        case "MemberExpression":
+        case "NewExpression":
+        case "ConditionalExpression":
+        case "YieldExpression":
+            return true;
+
+        default:
+            return false;
+        }
+
+    case "Literal":
+        return parent.type === "MemberExpression"
+            && isNumber.check(node.value)
+            && this.name === "object"
+            && parent.object === node;
+
+    case "AssignmentExpression":
+    case "ConditionalExpression":
+        switch (parent.type) {
+        case "UnaryExpression":
+        case "SpreadElement":
+        case "SpreadProperty":
+        case "BinaryExpression":
+        case "LogicalExpression":
+            return true;
+
+        case "CallExpression":
+            return this.name === "callee"
+                && parent.callee === node;
+
+        case "ConditionalExpression":
+            return this.name === "test"
+                && parent.test === node;
+
+        case "MemberExpression":
+            return this.name === "object"
+                && parent.object === node;
+
+        default:
+            return false;
+        }
+
+    default:
+        if (parent.type === "NewExpression" &&
+            this.name === "callee" &&
+            parent.callee === node) {
+            return containsCallExpression(node);
+        }
+    }
+
+    if (assumeExpressionContext !== true &&
+        !this.canBeFirstInStatement() &&
+        this.firstInStatement())
+        return true;
+
+    return false;
+};
+
+function isBinary(node) {
+    return n.BinaryExpression.check(node)
+        || n.LogicalExpression.check(node);
+}
+
+function isUnaryLike(node) {
+    return n.UnaryExpression.check(node)
+        // I considered making SpreadElement and SpreadProperty subtypes
+        // of UnaryExpression, but they're not really Expression nodes.
+        || (n.SpreadElement && n.SpreadElement.check(node))
+        || (n.SpreadProperty && n.SpreadProperty.check(node));
+}
+
+var PRECEDENCE = {};
+[["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"]
+].forEach(function(tier, i) {
+    tier.forEach(function(op) {
+        PRECEDENCE[op] = i;
+    });
+});
+
+function containsCallExpression(node) {
+    if (n.CallExpression.check(node)) {
+        return true;
+    }
+
+    if (isArray.check(node)) {
+        return node.some(containsCallExpression);
+    }
+
+    if (n.Node.check(node)) {
+        return types.someField(node, function(name, child) {
+            return containsCallExpression(child);
+        });
+    }
+
+    return false;
+}
+
+NPp.canBeFirstInStatement = function() {
+    var node = this.node;
+    return !n.FunctionExpression.check(node)
+        && !n.ObjectExpression.check(node);
+};
+
+NPp.firstInStatement = function() {
+    return firstInStatement(this);
+};
+
+function firstInStatement(path) {
+    for (var node, parent; path.parent; path = path.parent) {
+        node = path.node;
+        parent = path.parent.node;
+
+        if (n.BlockStatement.check(parent) &&
+            path.parent.name === "body" &&
+            path.name === 0) {
+            assert.strictEqual(parent.body[0], node);
+            return true;
+        }
+
+        if (n.ExpressionStatement.check(parent) &&
+            path.name === "expression") {
+            assert.strictEqual(parent.expression, node);
+            return true;
+        }
+
+        if (n.SequenceExpression.check(parent) &&
+            path.parent.name === "expressions" &&
+            path.name === 0) {
+            assert.strictEqual(parent.expressions[0], node);
+            continue;
+        }
+
+        if (n.CallExpression.check(parent) &&
+            path.name === "callee") {
+            assert.strictEqual(parent.callee, node);
+            continue;
+        }
+
+        if (n.MemberExpression.check(parent) &&
+            path.name === "object") {
+            assert.strictEqual(parent.object, node);
+            continue;
+        }
+
+        if (n.ConditionalExpression.check(parent) &&
+            path.name === "test") {
+            assert.strictEqual(parent.test, node);
+            continue;
+        }
+
+        if (isBinary(parent) &&
+            path.name === "left") {
+            assert.strictEqual(parent.left, node);
+            continue;
+        }
+
+        if (n.UnaryExpression.check(parent) &&
+            !parent.prefix &&
+            path.name === "argument") {
+            assert.strictEqual(parent.argument, node);
+            continue;
+        }
+
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * Pruning certain nodes will result in empty or incomplete nodes, here we clean those nodes up.
+ */
+function cleanUpNodesAfterPrune(remainingNodePath) {
+    if (n.VariableDeclaration.check(remainingNodePath.node)) {
+        var declarations = remainingNodePath.get('declarations').value;
+        if (!declarations || declarations.length === 0) {
+            return remainingNodePath.prune();
+        }
+    } else if (n.ExpressionStatement.check(remainingNodePath.node)) {
+        if (!remainingNodePath.get('expression').value) {
+            return remainingNodePath.prune();
+        }
+    } else if (n.IfStatement.check(remainingNodePath.node)) {
+        cleanUpIfStatementAfterPrune(remainingNodePath);
+    }
+
+    return remainingNodePath;
+}
+
+function cleanUpIfStatementAfterPrune(ifStatement) {
+    var testExpression = ifStatement.get('test').value;
+    var alternate = ifStatement.get('alternate').value;
+    var consequent = ifStatement.get('consequent').value;
+
+    if (!consequent && !alternate) {
+        var testExpressionStatement = b.expressionStatement(testExpression);
+
+        ifStatement.replace(testExpressionStatement);
+    } else if (!consequent && alternate) {
+        var negatedTestExpression = b.unaryExpression('!', testExpression, true);
+
+        if (n.UnaryExpression.check(testExpression) && testExpression.operator === '!') {
+            negatedTestExpression = testExpression.argument;
+        }
+
+        ifStatement.get("test").replace(negatedTestExpression);
+        ifStatement.get("consequent").replace(alternate);
+        ifStatement.get("alternate").replace();
+    }
+}
+
+module.exports = NodePath;
+
+},{"./path":132,"./scope":133,"./types":135,"assert":138,"util":163}],131:[function(require,module,exports){
+var assert = require("assert");
+var types = require("./types");
+var NodePath = require("./node-path");
+var Printable = types.namedTypes.Printable;
+var isArray = types.builtInTypes.array;
+var isObject = types.builtInTypes.object;
+var isFunction = types.builtInTypes.function;
+var hasOwn = Object.prototype.hasOwnProperty;
+var undefined;
+
+function PathVisitor() {
+    assert.ok(this instanceof PathVisitor);
+
+    // Permanent state.
+    this._reusableContextStack = [];
+
+    this._methodNameTable = computeMethodNameTable(this);
+    this._shouldVisitComments =
+        hasOwn.call(this._methodNameTable, "Block") ||
+        hasOwn.call(this._methodNameTable, "Line");
+
+    this.Context = makeContextConstructor(this);
+
+    // State reset every time PathVisitor.prototype.visit is called.
+    this._visiting = false;
+    this._changeReported = false;
+}
+
+function computeMethodNameTable(visitor) {
+    var typeNames = Object.create(null);
+
+    for (var methodName in visitor) {
+        if (/^visit[A-Z]/.test(methodName)) {
+            typeNames[methodName.slice("visit".length)] = true;
+        }
+    }
+
+    var supertypeTable = types.computeSupertypeLookupTable(typeNames);
+    var methodNameTable = Object.create(null);
+
+    var typeNames = Object.keys(supertypeTable);
+    var typeNameCount = typeNames.length;
+    for (var i = 0; i < typeNameCount; ++i) {
+        var typeName = typeNames[i];
+        methodName = "visit" + supertypeTable[typeName];
+        if (isFunction.check(visitor[methodName])) {
+            methodNameTable[typeName] = methodName;
+        }
+    }
+
+    return methodNameTable;
+}
+
+PathVisitor.fromMethodsObject = function fromMethodsObject(methods) {
+    if (methods instanceof PathVisitor) {
+        return methods;
+    }
+
+    if (!isObject.check(methods)) {
+        // An empty visitor?
+        return new PathVisitor;
+    }
+
+    function Visitor() {
+        assert.ok(this instanceof Visitor);
+        PathVisitor.call(this);
+    }
+
+    var Vp = Visitor.prototype = Object.create(PVp);
+    Vp.constructor = Visitor;
+
+    extend(Vp, methods);
+    extend(Visitor, PathVisitor);
+
+    isFunction.assert(Visitor.fromMethodsObject);
+    isFunction.assert(Visitor.visit);
+
+    return new Visitor;
+};
+
+function extend(target, source) {
+    for (var property in source) {
+        if (hasOwn.call(source, property)) {
+            target[property] = source[property];
+        }
+    }
+
+    return target;
+}
+
+PathVisitor.visit = function visit(node, methods) {
+    return PathVisitor.fromMethodsObject(methods).visit(node);
+};
+
+var PVp = PathVisitor.prototype;
+
+var recursiveVisitWarning = [
+    "Recursively calling visitor.visit(path) resets visitor state.",
+    "Try this.visit(path) or this.traverse(path) instead."
+].join(" ");
+
+PVp.visit = function() {
+    assert.ok(!this._visiting, recursiveVisitWarning);
+
+    // Private state that needs to be reset before every traversal.
+    this._visiting = true;
+    this._changeReported = false;
+    this._abortRequested = false;
+
+    var argc = arguments.length;
+    var args = new Array(argc)
+    for (var i = 0; i < argc; ++i) {
+        args[i] = arguments[i];
+    }
+
+    if (!(args[0] instanceof NodePath)) {
+        args[0] = new NodePath({ root: args[0] }).get("root");
+    }
+
+    // Called with the same arguments as .visit.
+    this.reset.apply(this, args);
+
+    try {
+        var root = this.visitWithoutReset(args[0]);
+        var didNotThrow = true;
+    } finally {
+        this._visiting = false;
+
+        if (!didNotThrow && this._abortRequested) {
+            // If this.visitWithoutReset threw an exception and
+            // this._abortRequested was set to true, return the root of
+            // the AST instead of letting the exception propagate, so that
+            // client code does not have to provide a try-catch block to
+            // intercept the AbortRequest exception.  Other kinds of
+            // exceptions will propagate without being intercepted and
+            // rethrown by a catch block, so their stacks will accurately
+            // reflect the original throwing context.
+            return args[0].value;
+        }
+    }
+
+    return root;
+};
+
+PVp.AbortRequest = function AbortRequest() {};
+PVp.abort = function() {
+    var visitor = this;
+    visitor._abortRequested = true;
+    var request = new visitor.AbortRequest();
+
+    // If you decide to catch this exception and stop it from propagating,
+    // make sure to call its cancel method to avoid silencing other
+    // exceptions that might be thrown later in the traversal.
+    request.cancel = function() {
+        visitor._abortRequested = false;
+    };
+
+    throw request;
+};
+
+PVp.reset = function(path/*, additional arguments */) {
+    // Empty stub; may be reassigned or overridden by subclasses.
+};
+
+PVp.visitWithoutReset = function(path) {
+    if (this instanceof this.Context) {
+        // Since this.Context.prototype === this, there's a chance we
+        // might accidentally call context.visitWithoutReset. If that
+        // happens, re-invoke the method against context.visitor.
+        return this.visitor.visitWithoutReset(path);
+    }
+
+    assert.ok(path instanceof NodePath);
+    var value = path.value;
+
+    var methodName = Printable.check(value) && this._methodNameTable[value.type];
+    if (methodName) {
+        var context = this.acquireContext(path);
+        try {
+            return context.invokeVisitorMethod(methodName);
+        } finally {
+            this.releaseContext(context);
+        }
+
+    } else {
+        // If there was no visitor method to call, visit the children of
+        // this node generically.
+        return visitChildren(path, this);
+    }
+};
+
+function visitChildren(path, visitor) {
+    assert.ok(path instanceof NodePath);
+    assert.ok(visitor instanceof PathVisitor);
+
+    var value = path.value;
+
+    if (isArray.check(value)) {
+        path.each(visitor.visitWithoutReset, visitor);
+    } else if (!isObject.check(value)) {
+        // No children to visit.
+    } else {
+        var childNames = types.getFieldNames(value);
+
+        // The .comments field of the Node type is hidden, so we only
+        // visit it if the visitor defines visitBlock or visitLine, and
+        // value.comments is defined.
+        if (visitor._shouldVisitComments &&
+            value.comments &&
+            childNames.indexOf("comments") < 0) {
+            childNames.push("comments");
+        }
+
+        var childCount = childNames.length;
+        var childPaths = [];
+
+        for (var i = 0; i < childCount; ++i) {
+            var childName = childNames[i];
+            if (!hasOwn.call(value, childName)) {
+                value[childName] = types.getFieldValue(value, childName);
+            }
+            childPaths.push(path.get(childName));
+        }
+
+        for (var i = 0; i < childCount; ++i) {
+            visitor.visitWithoutReset(childPaths[i]);
+        }
+    }
+
+    return path.value;
+}
+
+PVp.acquireContext = function(path) {
+    if (this._reusableContextStack.length === 0) {
+        return new this.Context(path);
+    }
+    return this._reusableContextStack.pop().reset(path);
+};
+
+PVp.releaseContext = function(context) {
+    assert.ok(context instanceof this.Context);
+    this._reusableContextStack.push(context);
+    context.currentPath = null;
+};
+
+PVp.reportChanged = function() {
+    this._changeReported = true;
+};
+
+PVp.wasChangeReported = function() {
+    return this._changeReported;
+};
+
+function makeContextConstructor(visitor) {
+    function Context(path) {
+        assert.ok(this instanceof Context);
+        assert.ok(this instanceof PathVisitor);
+        assert.ok(path instanceof NodePath);
+
+        Object.defineProperty(this, "visitor", {
+            value: visitor,
+            writable: false,
+            enumerable: true,
+            configurable: false
+        });
+
+        this.currentPath = path;
+        this.needToCallTraverse = true;
+
+        Object.seal(this);
+    }
+
+    assert.ok(visitor instanceof PathVisitor);
+
+    // Note that the visitor object is the prototype of Context.prototype,
+    // so all visitor methods are inherited by context objects.
+    var Cp = Context.prototype = Object.create(visitor);
+
+    Cp.constructor = Context;
+    extend(Cp, sharedContextProtoMethods);
+
+    return Context;
+}
+
+// Every PathVisitor has a different this.Context constructor and
+// this.Context.prototype object, but those prototypes can all use the
+// same reset, invokeVisitorMethod, and traverse function objects.
+var sharedContextProtoMethods = Object.create(null);
+
+sharedContextProtoMethods.reset =
+function reset(path) {
+    assert.ok(this instanceof this.Context);
+    assert.ok(path instanceof NodePath);
+
+    this.currentPath = path;
+    this.needToCallTraverse = true;
+
+    return this;
+};
+
+sharedContextProtoMethods.invokeVisitorMethod =
+function invokeVisitorMethod(methodName) {
+    assert.ok(this instanceof this.Context);
+    assert.ok(this.currentPath instanceof NodePath);
+
+    var result = this.visitor[methodName].call(this, this.currentPath);
+
+    if (result === false) {
+        // Visitor methods return false to indicate that they have handled
+        // their own traversal needs, and we should not complain if
+        // this.needToCallTraverse is still true.
+        this.needToCallTraverse = false;
+
+    } else if (result !== undefined) {
+        // Any other non-undefined value returned from the visitor method
+        // is interpreted as a replacement value.
+        this.currentPath = this.currentPath.replace(result)[0];
+
+        if (this.needToCallTraverse) {
+            // If this.traverse still hasn't been called, visit the
+            // children of the replacement node.
+            this.traverse(this.currentPath);
+        }
+    }
+
+    assert.strictEqual(
+        this.needToCallTraverse, false,
+        "Must either call this.traverse or return false in " + methodName
+    );
+
+    var path = this.currentPath;
+    return path && path.value;
+};
+
+sharedContextProtoMethods.traverse =
+function traverse(path, newVisitor) {
+    assert.ok(this instanceof this.Context);
+    assert.ok(path instanceof NodePath);
+    assert.ok(this.currentPath instanceof NodePath);
+
+    this.needToCallTraverse = false;
+
+    return visitChildren(path, PathVisitor.fromMethodsObject(
+        newVisitor || this.visitor
+    ));
+};
+
+sharedContextProtoMethods.visit =
+function visit(path, newVisitor) {
+    assert.ok(this instanceof this.Context);
+    assert.ok(path instanceof NodePath);
+    assert.ok(this.currentPath instanceof NodePath);
+
+    this.needToCallTraverse = false;
+
+    return PathVisitor.fromMethodsObject(
+        newVisitor || this.visitor
+    ).visitWithoutReset(path);
+};
+
+sharedContextProtoMethods.reportChanged = function reportChanged() {
+    this.visitor.reportChanged();
+};
+
+sharedContextProtoMethods.abort = function abort() {
+    this.needToCallTraverse = false;
+    this.visitor.abort();
+};
+
+module.exports = PathVisitor;
+
+},{"./node-path":130,"./types":135,"assert":138}],132:[function(require,module,exports){
+var assert = require("assert");
+var Op = Object.prototype;
+var hasOwn = Op.hasOwnProperty;
+var types = require("./types");
+var isArray = types.builtInTypes.array;
+var isNumber = types.builtInTypes.number;
+var Ap = Array.prototype;
+var slice = Ap.slice;
+var map = Ap.map;
+
+function Path(value, parentPath, name) {
+    assert.ok(this instanceof Path);
+
+    if (parentPath) {
+        assert.ok(parentPath instanceof Path);
+    } else {
+        parentPath = null;
+        name = null;
+    }
+
+    // The value encapsulated by this Path, generally equal to
+    // parentPath.value[name] if we have a parentPath.
+    this.value = value;
+
+    // The immediate parent Path of this Path.
+    this.parentPath = parentPath;
+
+    // The name of the property of parentPath.value through which this
+    // Path's value was reached.
+    this.name = name;
+
+    // Calling path.get("child") multiple times always returns the same
+    // child Path object, for both performance and consistency reasons.
+    this.__childCache = null;
+}
+
+var Pp = Path.prototype;
+
+function getChildCache(path) {
+    // Lazily create the child cache. This also cheapens cache
+    // invalidation, since you can just reset path.__childCache to null.
+    return path.__childCache || (path.__childCache = Object.create(null));
+}
+
+function getChildPath(path, name) {
+    var cache = getChildCache(path);
+    var actualChildValue = path.getValueProperty(name);
+    var childPath = cache[name];
+    if (!hasOwn.call(cache, name) ||
+        // Ensure consistency between cache and reality.
+        childPath.value !== actualChildValue) {
+        childPath = cache[name] = new path.constructor(
+            actualChildValue, path, name
+        );
+    }
+    return childPath;
+}
+
+// This method is designed to be overridden by subclasses that need to
+// handle missing properties, etc.
+Pp.getValueProperty = function getValueProperty(name) {
+    return this.value[name];
+};
+
+Pp.get = function get(name) {
+    var path = this;
+    var names = arguments;
+    var count = names.length;
+
+    for (var i = 0; i < count; ++i) {
+        path = getChildPath(path, names[i]);
+    }
+
+    return path;
+};
+
+Pp.each = function each(callback, context) {
+    var childPaths = [];
+    var len = this.value.length;
+    var i = 0;
+
+    // Collect all the original child paths before invoking the callback.
+    for (var i = 0; i < len; ++i) {
+        if (hasOwn.call(this.value, i)) {
+            childPaths[i] = this.get(i);
+        }
+    }
+
+    // Invoke the callback on just the original child paths, regardless of
+    // any modifications made to the array by the callback. I chose these
+    // semantics over cleverly invoking the callback on new elements because
+    // this way is much easier to reason about.
+    context = context || this;
+    for (i = 0; i < len; ++i) {
+        if (hasOwn.call(childPaths, i)) {
+            callback.call(context, childPaths[i]);
+        }
+    }
+};
+
+Pp.map = function map(callback, context) {
+    var result = [];
+
+    this.each(function(childPath) {
+        result.push(callback.call(this, childPath));
+    }, context);
+
+    return result;
+};
+
+Pp.filter = function filter(callback, context) {
+    var result = [];
+
+    this.each(function(childPath) {
+        if (callback.call(this, childPath)) {
+            result.push(childPath);
+        }
+    }, context);
+
+    return result;
+};
+
+function emptyMoves() {}
+function getMoves(path, offset, start, end) {
+    isArray.assert(path.value);
+
+    if (offset === 0) {
+        return emptyMoves;
+    }
+
+    var length = path.value.length;
+    if (length < 1) {
+        return emptyMoves;
+    }
+
+    var argc = arguments.length;
+    if (argc === 2) {
+        start = 0;
+        end = length;
+    } else if (argc === 3) {
+        start = Math.max(start, 0);
+        end = length;
+    } else {
+        start = Math.max(start, 0);
+        end = Math.min(end, length);
+    }
+
+    isNumber.assert(start);
+    isNumber.assert(end);
+
+    var moves = Object.create(null);
+    var cache = getChildCache(path);
+
+    for (var i = start; i < end; ++i) {
+        if (hasOwn.call(path.value, i)) {
+            var childPath = path.get(i);
+            assert.strictEqual(childPath.name, i);
+            var newIndex = i + offset;
+            childPath.name = newIndex;
+            moves[newIndex] = childPath;
+            delete cache[i];
+        }
+    }
+
+    delete cache.length;
+
+    return function() {
+        for (var newIndex in moves) {
+            var childPath = moves[newIndex];
+            assert.strictEqual(childPath.name, +newIndex);
+            cache[newIndex] = childPath;
+            path.value[newIndex] = childPath.value;
+        }
+    };
+}
+
+Pp.shift = function shift() {
+    var move = getMoves(this, -1);
+    var result = this.value.shift();
+    move();
+    return result;
+};
+
+Pp.unshift = function unshift(node) {
+    var move = getMoves(this, arguments.length);
+    var result = this.value.unshift.apply(this.value, arguments);
+    move();
+    return result;
+};
+
+Pp.push = function push(node) {
+    isArray.assert(this.value);
+    delete getChildCache(this).length
+    return this.value.push.apply(this.value, arguments);
+};
+
+Pp.pop = function pop() {
+    isArray.assert(this.value);
+    var cache = getChildCache(this);
+    delete cache[this.value.length - 1];
+    delete cache.length;
+    return this.value.pop();
+};
+
+Pp.insertAt = function insertAt(index, node) {
+    var argc = arguments.length;
+    var move = getMoves(this, argc - 1, index);
+    if (move === emptyMoves) {
+        return this;
+    }
+
+    index = Math.max(index, 0);
+
+    for (var i = 1; i < argc; ++i) {
+        this.value[index + i - 1] = arguments[i];
+    }
+
+    move();
+
+    return this;
+};
+
+Pp.insertBefore = function insertBefore(node) {
+    var pp = this.parentPath;
+    var argc = arguments.length;
+    var insertAtArgs = [this.name];
+    for (var i = 0; i < argc; ++i) {
+        insertAtArgs.push(arguments[i]);
+    }
+    return pp.insertAt.apply(pp, insertAtArgs);
+};
+
+Pp.insertAfter = function insertAfter(node) {
+    var pp = this.parentPath;
+    var argc = arguments.length;
+    var insertAtArgs = [this.name + 1];
+    for (var i = 0; i < argc; ++i) {
+        insertAtArgs.push(arguments[i]);
+    }
+    return pp.insertAt.apply(pp, insertAtArgs);
+};
+
+function repairRelationshipWithParent(path) {
+    assert.ok(path instanceof Path);
+
+    var pp = path.parentPath;
+    if (!pp) {
+        // Orphan paths have no relationship to repair.
+        return path;
+    }
+
+    var parentValue = pp.value;
+    var parentCache = getChildCache(pp);
+
+    // Make sure parentCache[path.name] is populated.
+    if (parentValue[path.name] === path.value) {
+        parentCache[path.name] = path;
+    } else if (isArray.check(parentValue)) {
+        // Something caused path.name to become out of date, so attempt to
+        // recover by searching for path.value in parentValue.
+        var i = parentValue.indexOf(path.value);
+        if (i >= 0) {
+            parentCache[path.name = i] = path;
+        }
+    } else {
+        // If path.value disagrees with parentValue[path.name], and
+        // path.name is not an array index, let path.value become the new
+        // parentValue[path.name] and update parentCache accordingly.
+        parentValue[path.name] = path.value;
+        parentCache[path.name] = path;
+    }
+
+    assert.strictEqual(parentValue[path.name], path.value);
+    assert.strictEqual(path.parentPath.get(path.name), path);
+
+    return path;
+}
+
+Pp.replace = function replace(replacement) {
+    var results = [];
+    var parentValue = this.parentPath.value;
+    var parentCache = getChildCache(this.parentPath);
+    var count = arguments.length;
+
+    repairRelationshipWithParent(this);
+
+    if (isArray.check(parentValue)) {
+        var originalLength = parentValue.length;
+        var move = getMoves(this.parentPath, count - 1, this.name + 1);
+
+        var spliceArgs = [this.name, 1];
+        for (var i = 0; i < count; ++i) {
+            spliceArgs.push(arguments[i]);
+        }
+
+        var splicedOut = parentValue.splice.apply(parentValue, spliceArgs);
+
+        assert.strictEqual(splicedOut[0], this.value);
+        assert.strictEqual(
+            parentValue.length,
+            originalLength - 1 + count
+        );
+
+        move();
+
+        if (count === 0) {
+            delete this.value;
+            delete parentCache[this.name];
+            this.__childCache = null;
+
+        } else {
+            assert.strictEqual(parentValue[this.name], replacement);
+
+            if (this.value !== replacement) {
+                this.value = replacement;
+                this.__childCache = null;
+            }
+
+            for (i = 0; i < count; ++i) {
+                results.push(this.parentPath.get(this.name + i));
+            }
+
+            assert.strictEqual(results[0], this);
+        }
+
+    } else if (count === 1) {
+        if (this.value !== replacement) {
+            this.__childCache = null;
+        }
+        this.value = parentValue[this.name] = replacement;
+        results.push(this);
+
+    } else if (count === 0) {
+        delete parentValue[this.name];
+        delete this.value;
+        this.__childCache = null;
+
+        // Leave this path cached as parentCache[this.name], even though
+        // it no longer has a value defined.
+
+    } else {
+        assert.ok(false, "Could not replace path");
+    }
+
+    return results;
+};
+
+module.exports = Path;
+
+},{"./types":135,"assert":138}],133:[function(require,module,exports){
+var assert = require("assert");
+var types = require("./types");
+var Type = types.Type;
+var namedTypes = types.namedTypes;
+var Node = namedTypes.Node;
+var Expression = namedTypes.Expression;
+var isArray = types.builtInTypes.array;
+var hasOwn = Object.prototype.hasOwnProperty;
+var b = types.builders;
+
+function Scope(path, parentScope) {
+    assert.ok(this instanceof Scope);
+    assert.ok(path instanceof require("./node-path"));
+    ScopeType.assert(path.value);
+
+    var depth;
+
+    if (parentScope) {
+        assert.ok(parentScope instanceof Scope);
+        depth = parentScope.depth + 1;
+    } else {
+        parentScope = null;
+        depth = 0;
+    }
+
+    Object.defineProperties(this, {
+        path: { value: path },
+        node: { value: path.value },
+        isGlobal: { value: !parentScope, enumerable: true },
+        depth: { value: depth },
+        parent: { value: parentScope },
+        bindings: { value: {} }
+    });
+}
+
+var scopeTypes = [
+    // Program nodes introduce global scopes.
+    namedTypes.Program,
+
+    // Function is the supertype of FunctionExpression,
+    // FunctionDeclaration, ArrowExpression, etc.
+    namedTypes.Function,
+
+    // In case you didn't know, the caught parameter shadows any variable
+    // of the same name in an outer scope.
+    namedTypes.CatchClause
+];
+
+var ScopeType = Type.or.apply(Type, scopeTypes);
+
+Scope.isEstablishedBy = function(node) {
+    return ScopeType.check(node);
+};
+
+var Sp = Scope.prototype;
+
+// Will be overridden after an instance lazily calls scanScope.
+Sp.didScan = false;
+
+Sp.declares = function(name) {
+    this.scan();
+    return hasOwn.call(this.bindings, name);
+};
+
+Sp.declareTemporary = function(prefix) {
+    if (prefix) {
+        assert.ok(/^[a-z$_]/i.test(prefix), prefix);
+    } else {
+        prefix = "t$";
+    }
+
+    // Include this.depth in the name to make sure the name does not
+    // collide with any variables in nested/enclosing scopes.
+    prefix += this.depth.toString(36) + "$";
+
+    this.scan();
+
+    var index = 0;
+    while (this.declares(prefix + index)) {
+        ++index;
+    }
+
+    var name = prefix + index;
+    return this.bindings[name] = types.builders.identifier(name);
+};
+
+Sp.injectTemporary = function(identifier, init) {
+    identifier || (identifier = this.declareTemporary());
+
+    var bodyPath = this.path.get("body");
+    if (namedTypes.BlockStatement.check(bodyPath.value)) {
+        bodyPath = bodyPath.get("body");
+    }
+
+    bodyPath.unshift(
+        b.variableDeclaration(
+            "var",
+            [b.variableDeclarator(identifier, init || null)]
+        )
+    );
+
+    return identifier;
+};
+
+Sp.scan = function(force) {
+    if (force || !this.didScan) {
+        for (var name in this.bindings) {
+            // Empty out this.bindings, just in cases.
+            delete this.bindings[name];
+        }
+        scanScope(this.path, this.bindings);
+        this.didScan = true;
+    }
+};
+
+Sp.getBindings = function () {
+    this.scan();
+    return this.bindings;
+};
+
+function scanScope(path, bindings) {
+    var node = path.value;
+    ScopeType.assert(node);
+
+    if (namedTypes.CatchClause.check(node)) {
+        // A catch clause establishes a new scope but the only variable
+        // bound in that scope is the catch parameter. Any other
+        // declarations create bindings in the outer scope.
+        addPattern(path.get("param"), bindings);
+
+    } else {
+        recursiveScanScope(path, bindings);
+    }
+}
+
+function recursiveScanScope(path, bindings) {
+    var node = path.value;
+
+    if (path.parent &&
+        namedTypes.FunctionExpression.check(path.parent.node) &&
+        path.parent.node.id) {
+        addPattern(path.parent.get("id"), bindings);
+    }
+
+    if (!node) {
+        // None of the remaining cases matter if node is falsy.
+
+    } else if (isArray.check(node)) {
+        path.each(function(childPath) {
+            recursiveScanChild(childPath, bindings);
+        });
+
+    } else if (namedTypes.Function.check(node)) {
+        path.get("params").each(function(paramPath) {
+            addPattern(paramPath, bindings);
+        });
+
+        recursiveScanChild(path.get("body"), bindings);
+
+    } else if (namedTypes.VariableDeclarator.check(node)) {
+        addPattern(path.get("id"), bindings);
+        recursiveScanChild(path.get("init"), bindings);
+
+    } else if (node.type === "ImportSpecifier" ||
+               node.type === "ImportNamespaceSpecifier" ||
+               node.type === "ImportDefaultSpecifier") {
+        addPattern(
+            node.name ? path.get("name") : path.get("id"),
+            bindings
+        );
+
+    } else if (Node.check(node) && !Expression.check(node)) {
+        types.eachField(node, function(name, child) {
+            var childPath = path.get(name);
+            assert.strictEqual(childPath.value, child);
+            recursiveScanChild(childPath, bindings);
+        });
+    }
+}
+
+function recursiveScanChild(path, bindings) {
+    var node = path.value;
+
+    if (!node || Expression.check(node)) {
+        // Ignore falsy values and Expressions.
+
+    } else if (namedTypes.FunctionDeclaration.check(node)) {
+        addPattern(path.get("id"), bindings);
+
+    } else if (namedTypes.ClassDeclaration &&
+               namedTypes.ClassDeclaration.check(node)) {
+        addPattern(path.get("id"), bindings);
+
+    } else if (ScopeType.check(node)) {
+        if (namedTypes.CatchClause.check(node)) {
+            var catchParamName = node.param.name;
+            var hadBinding = hasOwn.call(bindings, catchParamName);
+
+            // Any declarations that occur inside the catch body that do
+            // not have the same name as the catch parameter should count
+            // as bindings in the outer scope.
+            recursiveScanScope(path.get("body"), bindings);
+
+            // If a new binding matching the catch parameter name was
+            // created while scanning the catch body, ignore it because it
+            // actually refers to the catch parameter and not the outer
+            // scope that we're currently scanning.
+            if (!hadBinding) {
+                delete bindings[catchParamName];
+            }
+        }
+
+    } else {
+        recursiveScanScope(path, bindings);
+    }
+}
+
+function addPattern(patternPath, bindings) {
+    var pattern = patternPath.value;
+    namedTypes.Pattern.assert(pattern);
+
+    if (namedTypes.Identifier.check(pattern)) {
+        if (hasOwn.call(bindings, pattern.name)) {
+            bindings[pattern.name].push(patternPath);
+        } else {
+            bindings[pattern.name] = [patternPath];
+        }
+
+    } else if (namedTypes.ObjectPattern &&
+               namedTypes.ObjectPattern.check(pattern)) {
+        patternPath.get('properties').each(function(propertyPath) {
+            var property = propertyPath.value;
+            if (namedTypes.Pattern.check(property)) {
+                addPattern(propertyPath, bindings);
+            } else  if (namedTypes.Property.check(property)) {
+                addPattern(propertyPath.get('value'), bindings);
+            } else if (namedTypes.SpreadProperty &&
+                       namedTypes.SpreadProperty.check(property)) {
+                addPattern(propertyPath.get('argument'), bindings);
+            }
+        });
+
+    } else if (namedTypes.ArrayPattern &&
+               namedTypes.ArrayPattern.check(pattern)) {
+        patternPath.get('elements').each(function(elementPath) {
+            var element = elementPath.value;
+            if (namedTypes.Pattern.check(element)) {
+                addPattern(elementPath, bindings);
+            } else if (namedTypes.SpreadElement &&
+                       namedTypes.SpreadElement.check(element)) {
+                addPattern(elementPath.get("argument"), bindings);
+            }
+        });
+
+    } else if (namedTypes.PropertyPattern &&
+               namedTypes.PropertyPattern.check(pattern)) {
+        addPattern(patternPath.get('pattern'), bindings);
+
+    } else if ((namedTypes.SpreadElementPattern &&
+                namedTypes.SpreadElementPattern.check(pattern)) ||
+               (namedTypes.SpreadPropertyPattern &&
+                namedTypes.SpreadPropertyPattern.check(pattern))) {
+        addPattern(patternPath.get('argument'), bindings);
+    }
+}
+
+Sp.lookup = function(name) {
+    for (var scope = this; scope; scope = scope.parent)
+        if (scope.declares(name))
+            break;
+    return scope;
+};
+
+Sp.getGlobalScope = function() {
+    var scope = this;
+    while (!scope.isGlobal)
+        scope = scope.parent;
+    return scope;
+};
+
+module.exports = Scope;
+
+},{"./node-path":130,"./types":135,"assert":138}],134:[function(require,module,exports){
+var types = require("../lib/types");
+var Type = types.Type;
+var builtin = types.builtInTypes;
+var isNumber = builtin.number;
+
+// An example of constructing a new type with arbitrary constraints from
+// an existing type.
+exports.geq = function(than) {
+    return new Type(function(value) {
+        return isNumber.check(value) && value >= than;
+    }, isNumber + " >= " + than);
+};
+
+// Default value-returning functions that may optionally be passed as a
+// third argument to Def.prototype.field.
+exports.defaults = {
+    // Functions were used because (among other reasons) that's the most
+    // elegant way to allow for the emptyArray one always to give a new
+    // array instance.
+    "null": function() { return null },
+    "emptyArray": function() { return [] },
+    "false": function() { return false },
+    "true": function() { return true },
+    "undefined": function() {}
+};
+
+var naiveIsPrimitive = Type.or(
+    builtin.string,
+    builtin.number,
+    builtin.boolean,
+    builtin.null,
+    builtin.undefined
+);
+
+exports.isPrimitive = new Type(function(value) {
+    if (value === null)
+        return true;
+    var type = typeof value;
+    return !(type === "object" ||
+             type === "function");
+}, naiveIsPrimitive.toString());
+
+},{"../lib/types":135}],135:[function(require,module,exports){
+var assert = require("assert");
+var Ap = Array.prototype;
+var slice = Ap.slice;
+var map = Ap.map;
+var each = Ap.forEach;
+var Op = Object.prototype;
+var objToStr = Op.toString;
+var funObjStr = objToStr.call(function(){});
+var strObjStr = objToStr.call("");
+var hasOwn = Op.hasOwnProperty;
+
+// A type is an object with a .check method that takes a value and returns
+// true or false according to whether the value matches the type.
+
+function Type(check, name) {
+    var self = this;
+    assert.ok(self instanceof Type, self);
+
+    // Unfortunately we can't elegantly reuse isFunction and isString,
+    // here, because this code is executed while defining those types.
+    assert.strictEqual(objToStr.call(check), funObjStr,
+                       check + " is not a function");
+
+    // The `name` parameter can be either a function or a string.
+    var nameObjStr = objToStr.call(name);
+    assert.ok(nameObjStr === funObjStr ||
+              nameObjStr === strObjStr,
+              name + " is neither a function nor a string");
+
+    Object.defineProperties(self, {
+        name: { value: name },
+        check: {
+            value: function(value, deep) {
+                var result = check.call(self, value, deep);
+                if (!result && deep && objToStr.call(deep) === funObjStr)
+                    deep(self, value);
+                return result;
+            }
+        }
+    });
+}
+
+var Tp = Type.prototype;
+
+// Throughout this file we use Object.defineProperty to prevent
+// redefinition of exported properties.
+exports.Type = Type;
+
+// Like .check, except that failure triggers an AssertionError.
+Tp.assert = function(value, deep) {
+    if (!this.check(value, deep)) {
+        var str = shallowStringify(value);
+        assert.ok(false, str + " does not match type " + this);
+        return false;
+    }
+    return true;
+};
+
+function shallowStringify(value) {
+    if (isObject.check(value))
+        return "{" + Object.keys(value).map(function(key) {
+            return key + ": " + value[key];
+        }).join(", ") + "}";
+
+    if (isArray.check(value))
+        return "[" + value.map(shallowStringify).join(", ") + "]";
+
+    return JSON.stringify(value);
+}
+
+Tp.toString = function() {
+    var name = this.name;
+
+    if (isString.check(name))
+        return name;
+
+    if (isFunction.check(name))
+        return name.call(this) + "";
+
+    return name + " type";
+};
+
+var builtInTypes = {};
+exports.builtInTypes = builtInTypes;
+
+function defBuiltInType(example, name) {
+    var objStr = objToStr.call(example);
+
+    Object.defineProperty(builtInTypes, name, {
+        enumerable: true,
+        value: new Type(function(value) {
+            return objToStr.call(value) === objStr;
+        }, name)
+    });
+
+    return builtInTypes[name];
+}
+
+// These types check the underlying [[Class]] attribute of the given
+// value, rather than using the problematic typeof operator. Note however
+// that no subtyping is considered; so, for instance, isObject.check
+// returns false for [], /./, new Date, and null.
+var isString = defBuiltInType("", "string");
+var isFunction = defBuiltInType(function(){}, "function");
+var isArray = defBuiltInType([], "array");
+var isObject = defBuiltInType({}, "object");
+var isRegExp = defBuiltInType(/./, "RegExp");
+var isDate = defBuiltInType(new Date, "Date");
+var isNumber = defBuiltInType(3, "number");
+var isBoolean = defBuiltInType(true, "boolean");
+var isNull = defBuiltInType(null, "null");
+var isUndefined = defBuiltInType(void 0, "undefined");
+
+// There are a number of idiomatic ways of expressing types, so this
+// function serves to coerce them all to actual Type objects. Note that
+// providing the name argument is not necessary in most cases.
+function toType(from, name) {
+    // The toType function should of course be idempotent.
+    if (from instanceof Type)
+        return from;
+
+    // The Def type is used as a helper for constructing compound
+    // interface types for AST nodes.
+    if (from instanceof Def)
+        return from.type;
+
+    // Support [ElemType] syntax.
+    if (isArray.check(from))
+        return Type.fromArray(from);
+
+    // Support { someField: FieldType, ... } syntax.
+    if (isObject.check(from))
+        return Type.fromObject(from);
+
+    // If isFunction.check(from), assume that from is a binary predicate
+    // function we can use to define the type.
+    if (isFunction.check(from))
+        return new Type(from, name);
+
+    // As a last resort, toType returns a type that matches any value that
+    // is === from. This is primarily useful for literal values like
+    // toType(null), but it has the additional advantage of allowing
+    // toType to be a total function.
+    return new Type(function(value) {
+        return value === from;
+    }, isUndefined.check(name) ? function() {
+        return from + "";
+    } : name);
+}
+
+// Returns a type that matches the given value iff any of type1, type2,
+// etc. match the value.
+Type.or = function(/* type1, type2, ... */) {
+    var types = [];
+    var len = arguments.length;
+    for (var i = 0; i < len; ++i)
+        types.push(toType(arguments[i]));
+
+    return new Type(function(value, deep) {
+        for (var i = 0; i < len; ++i)
+            if (types[i].check(value, deep))
+                return true;
+        return false;
+    }, function() {
+        return types.join(" | ");
+    });
+};
+
+Type.fromArray = function(arr) {
+    assert.ok(isArray.check(arr));
+    assert.strictEqual(
+        arr.length, 1,
+        "only one element type is permitted for typed arrays");
+    return toType(arr[0]).arrayOf();
+};
+
+Tp.arrayOf = function() {
+    var elemType = this;
+    return new Type(function(value, deep) {
+        return isArray.check(value) && value.every(function(elem) {
+            return elemType.check(elem, deep);
+        });
+    }, function() {
+        return "[" + elemType + "]";
+    });
+};
+
+Type.fromObject = function(obj) {
+    var fields = Object.keys(obj).map(function(name) {
+        return new Field(name, obj[name]);
+    });
+
+    return new Type(function(value, deep) {
+        return isObject.check(value) && fields.every(function(field) {
+            return field.type.check(value[field.name], deep);
+        });
+    }, function() {
+        return "{ " + fields.join(", ") + " }";
+    });
+};
+
+function Field(name, type, defaultFn, hidden) {
+    var self = this;
+
+    assert.ok(self instanceof Field);
+    isString.assert(name);
+
+    type = toType(type);
+
+    var properties = {
+        name: { value: name },
+        type: { value: type },
+        hidden: { value: !!hidden }
+    };
+
+    if (isFunction.check(defaultFn)) {
+        properties.defaultFn = { value: defaultFn };
+    }
+
+    Object.defineProperties(self, properties);
+}
+
+var Fp = Field.prototype;
+
+Fp.toString = function() {
+    return JSON.stringify(this.name) + ": " + this.type;
+};
+
+Fp.getValue = function(obj) {
+    var value = obj[this.name];
+
+    if (!isUndefined.check(value))
+        return value;
+
+    if (this.defaultFn)
+        value = this.defaultFn.call(obj);
+
+    return value;
+};
+
+// Define a type whose name is registered in a namespace (the defCache) so
+// that future definitions will return the same type given the same name.
+// In particular, this system allows for circular and forward definitions.
+// The Def object d returned from Type.def may be used to configure the
+// type d.type by calling methods such as d.bases, d.build, and d.field.
+Type.def = function(typeName) {
+    isString.assert(typeName);
+    return hasOwn.call(defCache, typeName)
+        ? defCache[typeName]
+        : defCache[typeName] = new Def(typeName);
+};
+
+// In order to return the same Def instance every time Type.def is called
+// with a particular name, those instances need to be stored in a cache.
+var defCache = Object.create(null);
+
+function Def(typeName) {
+    var self = this;
+    assert.ok(self instanceof Def);
+
+    Object.defineProperties(self, {
+        typeName: { value: typeName },
+        baseNames: { value: [] },
+        ownFields: { value: Object.create(null) },
+
+        // These two are populated during finalization.
+        allSupertypes: { value: Object.create(null) }, // Includes own typeName.
+        supertypeList: { value: [] }, // Linear inheritance hierarchy.
+        allFields: { value: Object.create(null) }, // Includes inherited fields.
+        fieldNames: { value: [] }, // Non-hidden keys of allFields.
+
+        type: {
+            value: new Type(function(value, deep) {
+                return self.check(value, deep);
+            }, typeName)
+        }
+    });
+}
+
+Def.fromValue = function(value) {
+    if (value && typeof value === "object") {
+        var type = value.type;
+        if (typeof type === "string" &&
+            hasOwn.call(defCache, type)) {
+            var d = defCache[type];
+            if (d.finalized) {
+                return d;
+            }
+        }
+    }
+
+    return null;
+};
+
+var Dp = Def.prototype;
+
+Dp.isSupertypeOf = function(that) {
+    if (that instanceof Def) {
+        assert.strictEqual(this.finalized, true);
+        assert.strictEqual(that.finalized, true);
+        return hasOwn.call(that.allSupertypes, this.typeName);
+    } else {
+        assert.ok(false, that + " is not a Def");
+    }
+};
+
+// Note that the list returned by this function is a copy of the internal
+// supertypeList, *without* the typeName itself as the first element.
+exports.getSupertypeNames = function(typeName) {
+    assert.ok(hasOwn.call(defCache, typeName));
+    var d = defCache[typeName];
+    assert.strictEqual(d.finalized, true);
+    return d.supertypeList.slice(1);
+};
+
+// Returns an object mapping from every known type in the defCache to the
+// most specific supertype whose name is an own property of the candidates
+// object.
+exports.computeSupertypeLookupTable = function(candidates) {
+    var table = {};
+    var typeNames = Object.keys(defCache);
+    var typeNameCount = typeNames.length;
+
+    for (var i = 0; i < typeNameCount; ++i) {
+        var typeName = typeNames[i];
+        var d = defCache[typeName];
+        assert.strictEqual(d.finalized, true);
+        for (var j = 0; j < d.supertypeList.length; ++j) {
+            var superTypeName = d.supertypeList[j];
+            if (hasOwn.call(candidates, superTypeName)) {
+                table[typeName] = superTypeName;
+                break;
+            }
+        }
+    }
+
+    return table;
+};
+
+Dp.checkAllFields = function(value, deep) {
+    var allFields = this.allFields;
+    assert.strictEqual(this.finalized, true);
+
+    function checkFieldByName(name) {
+        var field = allFields[name];
+        var type = field.type;
+        var child = field.getValue(value);
+        return type.check(child, deep);
+    }
+
+    return isObject.check(value)
+        && Object.keys(allFields).every(checkFieldByName);
+};
+
+Dp.check = function(value, deep) {
+    assert.strictEqual(
+        this.finalized, true,
+        "prematurely checking unfinalized type " + this.typeName);
+
+    // A Def type can only match an object value.
+    if (!isObject.check(value))
+        return false;
+
+    var vDef = Def.fromValue(value);
+    if (!vDef) {
+        // If we couldn't infer the Def associated with the given value,
+        // and we expected it to be a SourceLocation or a Position, it was
+        // probably just missing a "type" field (because Esprima does not
+        // assign a type property to such nodes). Be optimistic and let
+        // this.checkAllFields make the final decision.
+        if (this.typeName === "SourceLocation" ||
+            this.typeName === "Position") {
+            return this.checkAllFields(value, deep);
+        }
+
+        // Calling this.checkAllFields for any other type of node is both
+        // bad for performance and way too forgiving.
+        return false;
+    }
+
+    // If checking deeply and vDef === this, then we only need to call
+    // checkAllFields once. Calling checkAllFields is too strict when deep
+    // is false, because then we only care about this.isSupertypeOf(vDef).
+    if (deep && vDef === this)
+        return this.checkAllFields(value, deep);
+
+    // In most cases we rely exclusively on isSupertypeOf to make O(1)
+    // subtyping determinations. This suffices in most situations outside
+    // of unit tests, since interface conformance is checked whenever new
+    // instances are created using builder functions.
+    if (!this.isSupertypeOf(vDef))
+        return false;
+
+    // The exception is when deep is true; then, we recursively check all
+    // fields.
+    if (!deep)
+        return true;
+
+    // Use the more specific Def (vDef) to perform the deep check, but
+    // shallow-check fields defined by the less specific Def (this).
+    return vDef.checkAllFields(value, deep)
+        && this.checkAllFields(value, false);
+};
+
+Dp.bases = function() {
+    var bases = this.baseNames;
+
+    assert.strictEqual(this.finalized, false);
+
+    each.call(arguments, function(baseName) {
+        isString.assert(baseName);
+
+        // This indexOf lookup may be O(n), but the typical number of base
+        // names is very small, and indexOf is a native Array method.
+        if (bases.indexOf(baseName) < 0)
+            bases.push(baseName);
+    });
+
+    return this; // For chaining.
+};
+
+// False by default until .build(...) is called on an instance.
+Object.defineProperty(Dp, "buildable", { value: false });
+
+var builders = {};
+exports.builders = builders;
+
+// This object is used as prototype for any node created by a builder.
+var nodePrototype = {};
+
+// Call this function to define a new method to be shared by all AST
+// nodes. The replaced method (if any) is returned for easy wrapping.
+exports.defineMethod = function(name, func) {
+    var old = nodePrototype[name];
+
+    // Pass undefined as func to delete nodePrototype[name].
+    if (isUndefined.check(func)) {
+        delete nodePrototype[name];
+
+    } else {
+        isFunction.assert(func);
+
+        Object.defineProperty(nodePrototype, name, {
+            enumerable: true, // For discoverability.
+            configurable: true, // For delete proto[name].
+            value: func
+        });
+    }
+
+    return old;
+};
+
+// Calling the .build method of a Def simultaneously marks the type as
+// buildable (by defining builders[getBuilderName(typeName)]) and
+// specifies the order of arguments that should be passed to the builder
+// function to create an instance of the type.
+Dp.build = function(/* param1, param2, ... */) {
+    var self = this;
+
+    // Calling Def.prototype.build multiple times has the effect of merely
+    // redefining this property.
+    Object.defineProperty(self, "buildParams", {
+        value: slice.call(arguments),
+        writable: false,
+        enumerable: false,
+        configurable: true
+    });
+
+    assert.strictEqual(self.finalized, false);
+    isString.arrayOf().assert(self.buildParams);
+
+    if (self.buildable) {
+        // If this Def is already buildable, update self.buildParams and
+        // continue using the old builder function.
+        return self;
+    }
+
+    // Every buildable type will have its "type" field filled in
+    // automatically. This includes types that are not subtypes of Node,
+    // like SourceLocation, but that seems harmless (TODO?).
+    self.field("type", self.typeName, function() { return self.typeName });
+
+    // Override Dp.buildable for this Def instance.
+    Object.defineProperty(self, "buildable", { value: true });
+
+    Object.defineProperty(builders, getBuilderName(self.typeName), {
+        enumerable: true,
+
+        value: function() {
+            var args = arguments;
+            var argc = args.length;
+            var built = Object.create(nodePrototype);
+
+            assert.ok(
+                self.finalized,
+                "attempting to instantiate unfinalized type " + self.typeName);
+
+            function add(param, i) {
+                if (hasOwn.call(built, param))
+                    return;
+
+                var all = self.allFields;
+                assert.ok(hasOwn.call(all, param), param);
+
+                var field = all[param];
+                var type = field.type;
+                var value;
+
+                if (isNumber.check(i) && i < argc) {
+                    value = args[i];
+                } else if (field.defaultFn) {
+                    // Expose the partially-built object to the default
+                    // function as its `this` object.
+                    value = field.defaultFn.call(built);
+                } else {
+                    var message = "no value or default function given for field " +
+                        JSON.stringify(param) + " of " + self.typeName + "(" +
+                            self.buildParams.map(function(name) {
+                                return all[name];
+                            }).join(", ") + ")";
+                    assert.ok(false, message);
+                }
+
+                if (!type.check(value)) {
+                    assert.ok(
+                        false,
+                        shallowStringify(value) +
+                            " does not match field " + field +
+                            " of type " + self.typeName
+                    );
+                }
+
+                // TODO Could attach getters and setters here to enforce
+                // dynamic type safety.
+                built[param] = value;
+            }
+
+            self.buildParams.forEach(function(param, i) {
+                add(param, i);
+            });
+
+            Object.keys(self.allFields).forEach(function(param) {
+                add(param); // Use the default value.
+            });
+
+            // Make sure that the "type" field was filled automatically.
+            assert.strictEqual(built.type, self.typeName);
+
+            return built;
+        }
+    });
+
+    return self; // For chaining.
+};
+
+function getBuilderName(typeName) {
+    return typeName.replace(/^[A-Z]+/, function(upperCasePrefix) {
+        var len = upperCasePrefix.length;
+        switch (len) {
+        case 0: return "";
+        // If there's only one initial capital letter, just lower-case it.
+        case 1: return upperCasePrefix.toLowerCase();
+        default:
+            // If there's more than one initial capital letter, lower-case
+            // all but the last one, so that XMLDefaultDeclaration (for
+            // example) becomes xmlDefaultDeclaration.
+            return upperCasePrefix.slice(
+                0, len - 1).toLowerCase() +
+                upperCasePrefix.charAt(len - 1);
+        }
+    });
+}
+
+// The reason fields are specified using .field(...) instead of an object
+// literal syntax is somewhat subtle: the object literal syntax would
+// support only one key and one value, but with .field(...) we can pass
+// any number of arguments to specify the field.
+Dp.field = function(name, type, defaultFn, hidden) {
+    assert.strictEqual(this.finalized, false);
+    this.ownFields[name] = new Field(name, type, defaultFn, hidden);
+    return this; // For chaining.
+};
+
+var namedTypes = {};
+exports.namedTypes = namedTypes;
+
+// Like Object.keys, but aware of what fields each AST type should have.
+function getFieldNames(object) {
+    var d = Def.fromValue(object);
+    if (d) {
+        return d.fieldNames.slice(0);
+    }
+
+    if ("type" in object) {
+        assert.ok(
+            false,
+            "did not recognize object of type " +
+                JSON.stringify(object.type)
+        );
+    }
+
+    return Object.keys(object);
+}
+exports.getFieldNames = getFieldNames;
+
+// Get the value of an object property, taking object.type and default
+// functions into account.
+function getFieldValue(object, fieldName) {
+    var d = Def.fromValue(object);
+    if (d) {
+        var field = d.allFields[fieldName];
+        if (field) {
+            return field.getValue(object);
+        }
+    }
+
+    return object[fieldName];
+}
+exports.getFieldValue = getFieldValue;
+
+// Iterate over all defined fields of an object, including those missing
+// or undefined, passing each field name and effective value (as returned
+// by getFieldValue) to the callback. If the object has no corresponding
+// Def, the callback will never be called.
+exports.eachField = function(object, callback, context) {
+    getFieldNames(object).forEach(function(name) {
+        callback.call(this, name, getFieldValue(object, name));
+    }, context);
+};
+
+// Similar to eachField, except that iteration stops as soon as the
+// callback returns a truthy value. Like Array.prototype.some, the final
+// result is either true or false to indicates whether the callback
+// returned true for any element or not.
+exports.someField = function(object, callback, context) {
+    return getFieldNames(object).some(function(name) {
+        return callback.call(this, name, getFieldValue(object, name));
+    }, context);
+};
+
+// This property will be overridden as true by individual Def instances
+// when they are finalized.
+Object.defineProperty(Dp, "finalized", { value: false });
+
+Dp.finalize = function() {
+    // It's not an error to finalize a type more than once, but only the
+    // first call to .finalize does anything.
+    if (!this.finalized) {
+        var allFields = this.allFields;
+        var allSupertypes = this.allSupertypes;
+
+        this.baseNames.forEach(function(name) {
+            var def = defCache[name];
+            def.finalize();
+            extend(allFields, def.allFields);
+            extend(allSupertypes, def.allSupertypes);
+        });
+
+        // TODO Warn if fields are overridden with incompatible types.
+        extend(allFields, this.ownFields);
+        allSupertypes[this.typeName] = this;
+
+        this.fieldNames.length = 0;
+        for (var fieldName in allFields) {
+            if (hasOwn.call(allFields, fieldName) &&
+                !allFields[fieldName].hidden) {
+                this.fieldNames.push(fieldName);
+            }
+        }
+
+        // Types are exported only once they have been finalized.
+        Object.defineProperty(namedTypes, this.typeName, {
+            enumerable: true,
+            value: this.type
+        });
+
+        Object.defineProperty(this, "finalized", { value: true });
+
+        // A linearization of the inheritance hierarchy.
+        populateSupertypeList(this.typeName, this.supertypeList);
+    }
+};
+
+function populateSupertypeList(typeName, list) {
+    list.length = 0;
+    list.push(typeName);
+
+    var lastSeen = Object.create(null);
+
+    for (var pos = 0; pos < list.length; ++pos) {
+        typeName = list[pos];
+        var d = defCache[typeName];
+        assert.strictEqual(d.finalized, true);
+
+        // If we saw typeName earlier in the breadth-first traversal,
+        // delete the last-seen occurrence.
+        if (hasOwn.call(lastSeen, typeName)) {
+            delete list[lastSeen[typeName]];
+        }
+
+        // Record the new index of the last-seen occurrence of typeName.
+        lastSeen[typeName] = pos;
+
+        // Enqueue the base names of this type.
+        list.push.apply(list, d.baseNames);
+    }
+
+    // Compaction loop to remove array holes.
+    for (var to = 0, from = to, len = list.length; from < len; ++from) {
+        if (hasOwn.call(list, from)) {
+            list[to++] = list[from];
+        }
+    }
+
+    list.length = to;
+}
+
+function extend(into, from) {
+    Object.keys(from).forEach(function(name) {
+        into[name] = from[name];
+    });
+
+    return into;
+};
+
+exports.finalize = function() {
+    Object.keys(defCache).forEach(function(name) {
+        defCache[name].finalize();
+    });
+};
+
+},{"assert":138}],136:[function(require,module,exports){
+var types = require("./lib/types");
+
+// This core module of AST types captures ES5 as it is parsed today by
+// git://github.com/ariya/esprima.git#master.
+require("./def/core");
+
+// Feel free to add to or remove from this list of extension modules to
+// configure the precise type hierarchy that you need.
+require("./def/es6");
+require("./def/es7");
+require("./def/mozilla");
+require("./def/e4x");
+require("./def/fb-harmony");
+
+types.finalize();
+
+exports.Type = types.Type;
+exports.builtInTypes = types.builtInTypes;
+exports.namedTypes = types.namedTypes;
+exports.builders = types.builders;
+exports.defineMethod = types.defineMethod;
+exports.getFieldNames = types.getFieldNames;
+exports.getFieldValue = types.getFieldValue;
+exports.eachField = types.eachField;
+exports.someField = types.someField;
+exports.getSupertypeNames = types.getSupertypeNames;
+exports.astNodesAreEquivalent = require("./lib/equiv");
+exports.finalize = types.finalize;
+exports.NodePath = require("./lib/node-path");
+exports.PathVisitor = require("./lib/path-visitor");
+exports.visit = exports.PathVisitor.visit;
+
+},{"./def/core":123,"./def/e4x":124,"./def/es6":125,"./def/es7":126,"./def/fb-harmony":127,"./def/mozilla":128,"./lib/equiv":129,"./lib/node-path":130,"./lib/path-visitor":131,"./lib/types":135}],137:[function(require,module,exports){
+
+},{}],138:[function(require,module,exports){
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// when used in node, this will actually load the util module we depend on
+// versus loading the builtin util module as happens otherwise
+// this is a bug in node module loading as far as I am concerned
+var util = require('util/');
+
+var pSlice = Array.prototype.slice;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = module.exports = ok;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+//                             actual: actual,
+//                             expected: expected })
+
+assert.AssertionError = function AssertionError(options) {
+  this.name = 'AssertionError';
+  this.actual = options.actual;
+  this.expected = options.expected;
+  this.operator = options.operator;
+  if (options.message) {
+    this.message = options.message;
+    this.generatedMessage = false;
+  } else {
+    this.message = getMessage(this);
+    this.generatedMessage = true;
+  }
+  var stackStartFunction = options.stackStartFunction || fail;
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  }
+  else {
+    // non v8 browsers so we can have a stacktrace
+    var err = new Error();
+    if (err.stack) {
+      var out = err.stack;
+
+      // try to strip useless frames
+      var fn_name = stackStartFunction.name;
+      var idx = out.indexOf('\n' + fn_name);
+      if (idx >= 0) {
+        // once we have located the function frame
+        // we need to strip out everything before it (and its line)
+        var next_line = out.indexOf('\n', idx + 1);
+        out = out.substring(next_line + 1);
+      }
+
+      this.stack = out;
+    }
+  }
+};
+
+// assert.AssertionError instanceof Error
+util.inherits(assert.AssertionError, Error);
+
+function replacer(key, value) {
+  if (util.isUndefined(value)) {
+    return '' + value;
+  }
+  if (util.isNumber(value) && !isFinite(value)) {
+    return value.toString();
+  }
+  if (util.isFunction(value) || util.isRegExp(value)) {
+    return value.toString();
+  }
+  return value;
+}
+
+function truncate(s, n) {
+  if (util.isString(s)) {
+    return s.length < n ? s : s.slice(0, n);
+  } else {
+    return s;
+  }
+}
+
+function getMessage(self) {
+  return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
+         self.operator + ' ' +
+         truncate(JSON.stringify(self.expected, replacer), 128);
+}
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided.  All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+  throw new assert.AssertionError({
+    message: message,
+    actual: actual,
+    expected: expected,
+    operator: operator,
+    stackStartFunction: stackStartFunction
+  });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, !!guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+function ok(value, message) {
+  if (!value) fail(value, true, message, '==', assert.ok);
+}
+assert.ok = ok;
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+  if (actual == expected) {
+    fail(actual, expected, message, '!=', assert.notEqual);
+  }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+  if (!_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+  }
+};
+
+function _deepEqual(actual, expected) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+
+  } else if (util.isBuffer(actual) && util.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+
+    return true;
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  } else if (util.isDate(actual) && util.isDate(expected)) {
+    return actual.getTime() === expected.getTime();
+
+  // 7.3 If the expected value is a RegExp object, the actual value is
+  // equivalent if it is also a RegExp object with the same source and
+  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+    return actual.source === expected.source &&
+           actual.global === expected.global &&
+           actual.multiline === expected.multiline &&
+           actual.lastIndex === expected.lastIndex &&
+           actual.ignoreCase === expected.ignoreCase;
+
+  // 7.4. Other pairs that do not both pass typeof value == 'object',
+  // equivalence is determined by ==.
+  } else if (!util.isObject(actual) && !util.isObject(expected)) {
+    return actual == expected;
+
+  // 7.5 For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical 'prototype' property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  } else {
+    return objEquiv(actual, expected);
+  }
+}
+
+function isArguments(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b) {
+  if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
+    return false;
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) return false;
+  // if one is a primitive, the other must be same
+  if (util.isPrimitive(a) || util.isPrimitive(b)) {
+    return a === b;
+  }
+  var aIsArgs = isArguments(a),
+      bIsArgs = isArguments(b);
+  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+    return false;
+  if (aIsArgs) {
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return _deepEqual(a, b);
+  }
+  var ka = objectKeys(a),
+      kb = objectKeys(b),
+      key, i;
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length != kb.length)
+    return false;
+  //the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  //~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i])
+      return false;
+  }
+  //equivalent values for every corresponding key, and
+  //~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!_deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+  if (_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+  }
+};
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+  if (actual !== expected) {
+    fail(actual, expected, message, '===', assert.strictEqual);
+  }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+  if (actual === expected) {
+    fail(actual, expected, message, '!==', assert.notStrictEqual);
+  }
+};
+
+function expectedException(actual, expected) {
+  if (!actual || !expected) {
+    return false;
+  }
+
+  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+    return expected.test(actual);
+  } else if (actual instanceof expected) {
+    return true;
+  } else if (expected.call({}, actual) === true) {
+    return true;
+  }
+
+  return false;
+}
+
+function _throws(shouldThrow, block, expected, message) {
+  var actual;
+
+  if (util.isString(expected)) {
+    message = expected;
+    expected = null;
+  }
+
+  try {
+    block();
+  } catch (e) {
+    actual = e;
+  }
+
+  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+            (message ? ' ' + message : '.');
+
+  if (shouldThrow && !actual) {
+    fail(actual, expected, 'Missing expected exception' + message);
+  }
+
+  if (!shouldThrow && expectedException(actual, expected)) {
+    fail(actual, expected, 'Got unwanted exception' + message);
+  }
+
+  if ((shouldThrow && actual && expected &&
+      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+    throw actual;
+  }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+  _throws.apply(this, [true].concat(pSlice.call(arguments)));
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/message) {
+  _throws.apply(this, [false].concat(pSlice.call(arguments)));
+};
+
+assert.ifError = function(err) { if (err) {throw err;}};
+
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (hasOwn.call(obj, key)) keys.push(key);
+  }
+  return keys;
+};
+
+},{"util/":163}],139:[function(require,module,exports){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+var isArray = require('is-array')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+Buffer.poolSize = 8192 // not used by this implementation
+
+var kMaxLength = 0x3fffffff
+var rootParent = {}
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ *   === true    Use Uint8Array implementation (fastest)
+ *   === false   Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Note:
+ *
+ * - Implementation must support adding new properties to `Uint8Array` instances.
+ *   Firefox 4-29 lacked support, fixed in Firefox 30+.
+ *   See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ *  - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ *  - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ *    incorrect length in some situations.
+ *
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will
+ * get the Object implementation, which is slower but will work correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = (function () {
+  try {
+    var buf = new ArrayBuffer(0)
+    var arr = new Uint8Array(buf)
+    arr.foo = function () { return 42 }
+    return arr.foo() === 42 && // typed array instances can be augmented
+        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+        new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+  } catch (e) {
+    return false
+  }
+})()
+
+/**
+ * Class: Buffer
+ * =============
+ *
+ * The Buffer constructor returns instances of `Uint8Array` that are augmented
+ * with function properties for all the node `Buffer` API functions. We use
+ * `Uint8Array` so that square bracket notation works as expected -- it returns
+ * a single octet.
+ *
+ * By augmenting the instances, we can avoid modifying the `Uint8Array`
+ * prototype.
+ */
+function Buffer (subject, encoding, noZero) {
+  if (!(this instanceof Buffer))
+    return new Buffer(subject, encoding, noZero)
+
+  var type = typeof subject
+
+  // Find the length
+  var length
+  if (type === 'number') {
+    length = +subject
+  } else if (type === 'string') {
+    length = Buffer.byteLength(subject, encoding)
+  } else if (type === 'object' && subject !== null) { // assume object is array-like
+    if (subject.type === 'Buffer' && isArray(subject.data))
+      subject = subject.data
+    length = +subject.length
+  } else {
+    throw new TypeError('must start with number, buffer, array or string')
+  }
+
+  if (length > kMaxLength)
+    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+      'size: 0x' + kMaxLength.toString(16) + ' bytes')
+
+  if (length < 0)
+    length = 0
+  else
+    length >>>= 0 // Coerce to uint32.
+
+  var self = this
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    // Preferred: Return an augmented `Uint8Array` instance for best performance
+    /*eslint-disable consistent-this */
+    self = Buffer._augment(new Uint8Array(length))
+    /*eslint-enable consistent-this */
+  } else {
+    // Fallback: Return THIS instance of Buffer (created by `new`)
+    self.length = length
+    self._isBuffer = true
+  }
+
+  var i
+  if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') {
+    // Speed optimization -- use set if we're copying from a typed array
+    self._set(subject)
+  } else if (isArrayish(subject)) {
+    // Treat array-ish objects as a byte array
+    if (Buffer.isBuffer(subject)) {
+      for (i = 0; i < length; i++)
+        self[i] = subject.readUInt8(i)
+    } else {
+      for (i = 0; i < length; i++)
+        self[i] = ((subject[i] % 256) + 256) % 256
+    }
+  } else if (type === 'string') {
+    self.write(subject, 0, encoding)
+  } else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) {
+    for (i = 0; i < length; i++) {
+      self[i] = 0
+    }
+  }
+
+  if (length > 0 && length <= Buffer.poolSize)
+    self.parent = rootParent
+
+  return self
+}
+
+function SlowBuffer (subject, encoding, noZero) {
+  if (!(this instanceof SlowBuffer))
+    return new SlowBuffer(subject, encoding, noZero)
+
+  var buf = new Buffer(subject, encoding, noZero)
+  delete buf.parent
+  return buf
+}
+
+Buffer.isBuffer = function (b) {
+  return !!(b != null && b._isBuffer)
+}
+
+Buffer.compare = function (a, b) {
+  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b))
+    throw new TypeError('Arguments must be Buffers')
+
+  if (a === b) return 0
+
+  var x = a.length
+  var y = b.length
+  for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {}
+  if (i !== len) {
+    x = a[i]
+    y = b[i]
+  }
+  if (x < y) return -1
+  if (y < x) return 1
+  return 0
+}
+
+Buffer.isEncoding = function (encoding) {
+  switch (String(encoding).toLowerCase()) {
+    case 'hex':
+    case 'utf8':
+    case 'utf-8':
+    case 'ascii':
+    case 'binary':
+    case 'base64':
+    case 'raw':
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      return true
+    default:
+      return false
+  }
+}
+
+Buffer.concat = function (list, totalLength) {
+  if (!isArray(list)) throw new TypeError('Usage: Buffer.concat(list[, length])')
+
+  if (list.length === 0) {
+    return new Buffer(0)
+  } else if (list.length === 1) {
+    return list[0]
+  }
+
+  var i
+  if (totalLength === undefined) {
+    totalLength = 0
+    for (i = 0; i < list.length; i++) {
+      totalLength += list[i].length
+    }
+  }
+
+  var buf = new Buffer(totalLength)
+  var pos = 0
+  for (i = 0; i < list.length; i++) {
+    var item = list[i]
+    item.copy(buf, pos)
+    pos += item.length
+  }
+  return buf
+}
+
+Buffer.byteLength = function (str, encoding) {
+  var ret
+  str = str + ''
+  switch (encoding || 'utf8') {
+    case 'ascii':
+    case 'binary':
+    case 'raw':
+      ret = str.length
+      break
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      ret = str.length * 2
+      break
+    case 'hex':
+      ret = str.length >>> 1
+      break
+    case 'utf8':
+    case 'utf-8':
+      ret = utf8ToBytes(str).length
+      break
+    case 'base64':
+      ret = base64ToBytes(str).length
+      break
+    default:
+      ret = str.length
+  }
+  return ret
+}
+
+// pre-set for values that may exist in the future
+Buffer.prototype.length = undefined
+Buffer.prototype.parent = undefined
+
+// toString(encoding, start=0, end=buffer.length)
+Buffer.prototype.toString = function (encoding, start, end) {
+  var loweredCase = false
+
+  start = start >>> 0
+  end = end === undefined || end === Infinity ? this.length : end >>> 0
+
+  if (!encoding) encoding = 'utf8'
+  if (start < 0) start = 0
+  if (end > this.length) end = this.length
+  if (end <= start) return ''
+
+  while (true) {
+    switch (encoding) {
+      case 'hex':
+        return hexSlice(this, start, end)
+
+      case 'utf8':
+      case 'utf-8':
+        return utf8Slice(this, start, end)
+
+      case 'ascii':
+        return asciiSlice(this, start, end)
+
+      case 'binary':
+        return binarySlice(this, start, end)
+
+      case 'base64':
+        return base64Slice(this, start, end)
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return utf16leSlice(this, start, end)
+
+      default:
+        if (loweredCase)
+          throw new TypeError('Unknown encoding: ' + encoding)
+        encoding = (encoding + '').toLowerCase()
+        loweredCase = true
+    }
+  }
+}
+
+Buffer.prototype.equals = function (b) {
+  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+  if (this === b) return true
+  return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function () {
+  var str = ''
+  var max = exports.INSPECT_MAX_BYTES
+  if (this.length > 0) {
+    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+    if (this.length > max)
+      str += ' ... '
+  }
+  return '<Buffer ' + str + '>'
+}
+
+Buffer.prototype.compare = function (b) {
+  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+  if (this === b) return 0
+  return Buffer.compare(this, b)
+}
+
+// `get` will be removed in Node 0.13+
+Buffer.prototype.get = function (offset) {
+  console.log('.get() is deprecated. Access using array indexes instead.')
+  return this.readUInt8(offset)
+}
+
+// `set` will be removed in Node 0.13+
+Buffer.prototype.set = function (v, offset) {
+  console.log('.set() is deprecated. Access using array indexes instead.')
+  return this.writeUInt8(v, offset)
+}
+
+function hexWrite (buf, string, offset, length) {
+  offset = Number(offset) || 0
+  var remaining = buf.length - offset
+  if (!length) {
+    length = remaining
+  } else {
+    length = Number(length)
+    if (length > remaining) {
+      length = remaining
+    }
+  }
+
+  // must be an even number of digits
+  var strLen = string.length
+  if (strLen % 2 !== 0) throw new Error('Invalid hex string')
+
+  if (length > strLen / 2) {
+    length = strLen / 2
+  }
+  for (var i = 0; i < length; i++) {
+    var byte = parseInt(string.substr(i * 2, 2), 16)
+    if (isNaN(byte)) throw new Error('Invalid hex string')
+    buf[offset + i] = byte
+  }
+  return i
+}
+
+function utf8Write (buf, string, offset, length) {
+  var charsWritten = blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+  return charsWritten
+}
+
+function asciiWrite (buf, string, offset, length) {
+  var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length)
+  return charsWritten
+}
+
+function binaryWrite (buf, string, offset, length) {
+  return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+  var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length)
+  return charsWritten
+}
+
+function utf16leWrite (buf, string, offset, length) {
+  var charsWritten = blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+  return charsWritten
+}
+
+Buffer.prototype.write = function (string, offset, length, encoding) {
+  // Support both (string, offset, length, encoding)
+  // and the legacy (string, encoding, offset, length)
+  if (isFinite(offset)) {
+    if (!isFinite(length)) {
+      encoding = length
+      length = undefined
+    }
+  } else {  // legacy
+    var swap = encoding
+    encoding = offset
+    offset = length
+    length = swap
+  }
+
+  offset = Number(offset) || 0
+
+  if (length < 0 || offset < 0 || offset > this.length)
+    throw new RangeError('attempt to write outside buffer bounds')
+
+  var remaining = this.length - offset
+  if (!length) {
+    length = remaining
+  } else {
+    length = Number(length)
+    if (length > remaining) {
+      length = remaining
+    }
+  }
+  encoding = String(encoding || 'utf8').toLowerCase()
+
+  var ret
+  switch (encoding) {
+    case 'hex':
+      ret = hexWrite(this, string, offset, length)
+      break
+    case 'utf8':
+    case 'utf-8':
+      ret = utf8Write(this, string, offset, length)
+      break
+    case 'ascii':
+      ret = asciiWrite(this, string, offset, length)
+      break
+    case 'binary':
+      ret = binaryWrite(this, string, offset, length)
+      break
+    case 'base64':
+      ret = base64Write(this, string, offset, length)
+      break
+    case 'ucs2':
+    case 'ucs-2':
+    case 'utf16le':
+    case 'utf-16le':
+      ret = utf16leWrite(this, string, offset, length)
+      break
+    default:
+      throw new TypeError('Unknown encoding: ' + encoding)
+  }
+  return ret
+}
+
+Buffer.prototype.toJSON = function () {
+  return {
+    type: 'Buffer',
+    data: Array.prototype.slice.call(this._arr || this, 0)
+  }
+}
+
+function base64Slice (buf, start, end) {
+  if (start === 0 && end === buf.length) {
+    return base64.fromByteArray(buf)
+  } else {
+    return base64.fromByteArray(buf.slice(start, end))
+  }
+}
+
+function utf8Slice (buf, start, end) {
+  var res = ''
+  var tmp = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; i++) {
+    if (buf[i] <= 0x7F) {
+      res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
+      tmp = ''
+    } else {
+      tmp += '%' + buf[i].toString(16)
+    }
+  }
+
+  return res + decodeUtf8Char(tmp)
+}
+
+function asciiSlice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; i++) {
+    ret += String.fromCharCode(buf[i] & 0x7F)
+  }
+  return ret
+}
+
+function binarySlice (buf, start, end) {
+  var ret = ''
+  end = Math.min(buf.length, end)
+
+  for (var i = start; i < end; i++) {
+    ret += String.fromCharCode(buf[i])
+  }
+  return ret
+}
+
+function hexSlice (buf, start, end) {
+  var len = buf.length
+
+  if (!start || start < 0) start = 0
+  if (!end || end < 0 || end > len) end = len
+
+  var out = ''
+  for (var i = start; i < end; i++) {
+    out += toHex(buf[i])
+  }
+  return out
+}
+
+function utf16leSlice (buf, start, end) {
+  var bytes = buf.slice(start, end)
+  var res = ''
+  for (var i = 0; i < bytes.length; i += 2) {
+    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+  }
+  return res
+}
+
+Buffer.prototype.slice = function (start, end) {
+  var len = this.length
+  start = ~~start
+  end = end === undefined ? len : ~~end
+
+  if (start < 0) {
+    start += len
+    if (start < 0)
+      start = 0
+  } else if (start > len) {
+    start = len
+  }
+
+  if (end < 0) {
+    end += len
+    if (end < 0)
+      end = 0
+  } else if (end > len) {
+    end = len
+  }
+
+  if (end < start)
+    end = start
+
+  var newBuf
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    newBuf = Buffer._augment(this.subarray(start, end))
+  } else {
+    var sliceLen = end - start
+    newBuf = new Buffer(sliceLen, undefined, true)
+    for (var i = 0; i < sliceLen; i++) {
+      newBuf[i] = this[i + start]
+    }
+  }
+
+  if (newBuf.length)
+    newBuf.parent = this.parent || this
+
+  return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+  if ((offset % 1) !== 0 || offset < 0)
+    throw new RangeError('offset is not uint')
+  if (offset + ext > length)
+    throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert)
+    checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100))
+    val += this[offset + i] * mul
+
+  return val
+}
+
+Buffer.prototype.readUIntBE = function (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert)
+    checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset + --byteLength]
+  var mul = 1
+  while (byteLength > 0 && (mul *= 0x100))
+    val += this[offset + --byteLength] * mul
+
+  return val
+}
+
+Buffer.prototype.readUInt8 = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 1, this.length)
+  return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 2, this.length)
+  return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 2, this.length)
+  return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 4, this.length)
+
+  return ((this[offset]) |
+      (this[offset + 1] << 8) |
+      (this[offset + 2] << 16)) +
+      (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 4, this.length)
+
+  return (this[offset] * 0x1000000) +
+      ((this[offset + 1] << 16) |
+      (this[offset + 2] << 8) |
+      this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert)
+    checkOffset(offset, byteLength, this.length)
+
+  var val = this[offset]
+  var mul = 1
+  var i = 0
+  while (++i < byteLength && (mul *= 0x100))
+    val += this[offset + i] * mul
+  mul *= 0x80
+
+  if (val >= mul)
+    val -= Math.pow(2, 8 * byteLength)
+
+  return val
+}
+
+Buffer.prototype.readIntBE = function (offset, byteLength, noAssert) {
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert)
+    checkOffset(offset, byteLength, this.length)
+
+  var i = byteLength
+  var mul = 1
+  var val = this[offset + --i]
+  while (i > 0 && (mul *= 0x100))
+    val += this[offset + --i] * mul
+  mul *= 0x80
+
+  if (val >= mul)
+    val -= Math.pow(2, 8 * byteLength)
+
+  return val
+}
+
+Buffer.prototype.readInt8 = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 1, this.length)
+  if (!(this[offset] & 0x80))
+    return (this[offset])
+  return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 2, this.length)
+  var val = this[offset] | (this[offset + 1] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 2, this.length)
+  var val = this[offset + 1] | (this[offset] << 8)
+  return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 4, this.length)
+
+  return (this[offset]) |
+      (this[offset + 1] << 8) |
+      (this[offset + 2] << 16) |
+      (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 4, this.length)
+
+  return (this[offset] << 24) |
+      (this[offset + 1] << 16) |
+      (this[offset + 2] << 8) |
+      (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 4, this.length)
+  return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function (offset, noAssert) {
+  if (!noAssert)
+    checkOffset(offset, 8, this.length)
+  return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
+  if (value > max || value < min) throw new RangeError('value is out of bounds')
+  if (offset + ext > buf.length) throw new RangeError('index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
+
+  var mul = 1
+  var i = 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100))
+    this[offset + i] = (value / mul) >>> 0 & 0xFF
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  byteLength = byteLength >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
+
+  var i = byteLength - 1
+  var mul = 1
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100))
+    this[offset + i] = (value / mul) >>> 0 & 0xFF
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 1, 0xff, 0)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+  this[offset] = value
+  return offset + 1
+}
+
+function objectWriteUInt16 (buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffff + value + 1
+  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
+    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+      (littleEndian ? i : 1 - i) * 8
+  }
+}
+
+Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 2, 0xffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value
+    this[offset + 1] = (value >>> 8)
+  } else objectWriteUInt16(this, value, offset, true)
+  return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 2, 0xffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 8)
+    this[offset + 1] = value
+  } else objectWriteUInt16(this, value, offset, false)
+  return offset + 2
+}
+
+function objectWriteUInt32 (buf, value, offset, littleEndian) {
+  if (value < 0) value = 0xffffffff + value + 1
+  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
+    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+  }
+}
+
+Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 4, 0xffffffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset + 3] = (value >>> 24)
+    this[offset + 2] = (value >>> 16)
+    this[offset + 1] = (value >>> 8)
+    this[offset] = value
+  } else objectWriteUInt32(this, value, offset, true)
+  return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 4, 0xffffffff, 0)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 24)
+    this[offset + 1] = (value >>> 16)
+    this[offset + 2] = (value >>> 8)
+    this[offset + 3] = value
+  } else objectWriteUInt32(this, value, offset, false)
+  return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) {
+    checkInt(this,
+             value,
+             offset,
+             byteLength,
+             Math.pow(2, 8 * byteLength - 1) - 1,
+             -Math.pow(2, 8 * byteLength - 1))
+  }
+
+  var i = 0
+  var mul = 1
+  var sub = value < 0 ? 1 : 0
+  this[offset] = value & 0xFF
+  while (++i < byteLength && (mul *= 0x100))
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function (value, offset, byteLength, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert) {
+    checkInt(this,
+             value,
+             offset,
+             byteLength,
+             Math.pow(2, 8 * byteLength - 1) - 1,
+             -Math.pow(2, 8 * byteLength - 1))
+  }
+
+  var i = byteLength - 1
+  var mul = 1
+  var sub = value < 0 ? 1 : 0
+  this[offset + i] = value & 0xFF
+  while (--i >= 0 && (mul *= 0x100))
+    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+
+  return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 1, 0x7f, -0x80)
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+  if (value < 0) value = 0xff + value + 1
+  this[offset] = value
+  return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value
+    this[offset + 1] = (value >>> 8)
+  } else objectWriteUInt16(this, value, offset, true)
+  return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 8)
+    this[offset + 1] = value
+  } else objectWriteUInt16(this, value, offset, false)
+  return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = value
+    this[offset + 1] = (value >>> 8)
+    this[offset + 2] = (value >>> 16)
+    this[offset + 3] = (value >>> 24)
+  } else objectWriteUInt32(this, value, offset, true)
+  return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
+  value = +value
+  offset = offset >>> 0
+  if (!noAssert)
+    checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+  if (value < 0) value = 0xffffffff + value + 1
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
+    this[offset] = (value >>> 24)
+    this[offset + 1] = (value >>> 16)
+    this[offset + 2] = (value >>> 8)
+    this[offset + 3] = value
+  } else objectWriteUInt32(this, value, offset, false)
+  return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+  if (value > max || value < min) throw new RangeError('value is out of bounds')
+  if (offset + ext > buf.length) throw new RangeError('index out of range')
+  if (offset < 0) throw new RangeError('index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert)
+    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+  ieee754.write(buf, value, offset, littleEndian, 23, 4)
+  return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
+  return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
+  return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+  if (!noAssert)
+    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+  ieee754.write(buf, value, offset, littleEndian, 52, 8)
+  return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
+  return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
+  return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function (target, target_start, start, end) {
+  var self = this // source
+
+  if (!start) start = 0
+  if (!end && end !== 0) end = this.length
+  if (target_start >= target.length) target_start = target.length
+  if (!target_start) target_start = 0
+  if (end > 0 && end < start) end = start
+
+  // Copy 0 bytes; we're done
+  if (end === start) return 0
+  if (target.length === 0 || self.length === 0) return 0
+
+  // Fatal error conditions
+  if (target_start < 0)
+    throw new RangeError('targetStart out of bounds')
+  if (start < 0 || start >= self.length) throw new RangeError('sourceStart out of bounds')
+  if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+  // Are we oob?
+  if (end > this.length)
+    end = this.length
+  if (target.length - target_start < end - start)
+    end = target.length - target_start + start
+
+  var len = end - start
+
+  if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+    for (var i = 0; i < len; i++) {
+      target[i + target_start] = this[i + start]
+    }
+  } else {
+    target._set(this.subarray(start, start + len), target_start)
+  }
+
+  return len
+}
+
+// fill(value, start=0, end=buffer.length)
+Buffer.prototype.fill = function (value, start, end) {
+  if (!value) value = 0
+  if (!start) start = 0
+  if (!end) end = this.length
+
+  if (end < start) throw new RangeError('end < start')
+
+  // Fill 0 bytes; we're done
+  if (end === start) return
+  if (this.length === 0) return
+
+  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
+  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
+
+  var i
+  if (typeof value === 'number') {
+    for (i = start; i < end; i++) {
+      this[i] = value
+    }
+  } else {
+    var bytes = utf8ToBytes(value.toString())
+    var len = bytes.length
+    for (i = start; i < end; i++) {
+      this[i] = bytes[i % len]
+    }
+  }
+
+  return this
+}
+
+/**
+ * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
+ * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
+ */
+Buffer.prototype.toArrayBuffer = function () {
+  if (typeof Uint8Array !== 'undefined') {
+    if (Buffer.TYPED_ARRAY_SUPPORT) {
+      return (new Buffer(this)).buffer
+    } else {
+      var buf = new Uint8Array(this.length)
+      for (var i = 0, len = buf.length; i < len; i += 1) {
+        buf[i] = this[i]
+      }
+      return buf.buffer
+    }
+  } else {
+    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
+  }
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var BP = Buffer.prototype
+
+/**
+ * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
+ */
+Buffer._augment = function (arr) {
+  arr.constructor = Buffer
+  arr._isBuffer = true
+
+  // save reference to original Uint8Array get/set methods before overwriting
+  arr._get = arr.get
+  arr._set = arr.set
+
+  // deprecated, will be removed in node 0.13+
+  arr.get = BP.get
+  arr.set = BP.set
+
+  arr.write = BP.write
+  arr.toString = BP.toString
+  arr.toLocaleString = BP.toString
+  arr.toJSON = BP.toJSON
+  arr.equals = BP.equals
+  arr.compare = BP.compare
+  arr.copy = BP.copy
+  arr.slice = BP.slice
+  arr.readUIntLE = BP.readUIntLE
+  arr.readUIntBE = BP.readUIntBE
+  arr.readUInt8 = BP.readUInt8
+  arr.readUInt16LE = BP.readUInt16LE
+  arr.readUInt16BE = BP.readUInt16BE
+  arr.readUInt32LE = BP.readUInt32LE
+  arr.readUInt32BE = BP.readUInt32BE
+  arr.readIntLE = BP.readIntLE
+  arr.readIntBE = BP.readIntBE
+  arr.readInt8 = BP.readInt8
+  arr.readInt16LE = BP.readInt16LE
+  arr.readInt16BE = BP.readInt16BE
+  arr.readInt32LE = BP.readInt32LE
+  arr.readInt32BE = BP.readInt32BE
+  arr.readFloatLE = BP.readFloatLE
+  arr.readFloatBE = BP.readFloatBE
+  arr.readDoubleLE = BP.readDoubleLE
+  arr.readDoubleBE = BP.readDoubleBE
+  arr.writeUInt8 = BP.writeUInt8
+  arr.writeUIntLE = BP.writeUIntLE
+  arr.writeUIntBE = BP.writeUIntBE
+  arr.writeUInt16LE = BP.writeUInt16LE
+  arr.writeUInt16BE = BP.writeUInt16BE
+  arr.writeUInt32LE = BP.writeUInt32LE
+  arr.writeUInt32BE = BP.writeUInt32BE
+  arr.writeIntLE = BP.writeIntLE
+  arr.writeIntBE = BP.writeIntBE
+  arr.writeInt8 = BP.writeInt8
+  arr.writeInt16LE = BP.writeInt16LE
+  arr.writeInt16BE = BP.writeInt16BE
+  arr.writeInt32LE = BP.writeInt32LE
+  arr.writeInt32BE = BP.writeInt32BE
+  arr.writeFloatLE = BP.writeFloatLE
+  arr.writeFloatBE = BP.writeFloatBE
+  arr.writeDoubleLE = BP.writeDoubleLE
+  arr.writeDoubleBE = BP.writeDoubleBE
+  arr.fill = BP.fill
+  arr.inspect = BP.inspect
+  arr.toArrayBuffer = BP.toArrayBuffer
+
+  return arr
+}
+
+var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g
+
+function base64clean (str) {
+  // Node strips out invalid characters like \n and \t from the string, base64-js does not
+  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+  // Node converts strings with length < 2 to ''
+  if (str.length < 2) return ''
+  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+  while (str.length % 4 !== 0) {
+    str = str + '='
+  }
+  return str
+}
+
+function stringtrim (str) {
+  if (str.trim) return str.trim()
+  return str.replace(/^\s+|\s+$/g, '')
+}
+
+function isArrayish (subject) {
+  return isArray(subject) || Buffer.isBuffer(subject) ||
+      subject && typeof subject === 'object' &&
+      typeof subject.length === 'number'
+}
+
+function toHex (n) {
+  if (n < 16) return '0' + n.toString(16)
+  return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+  units = units || Infinity
+  var codePoint
+  var length = string.length
+  var leadSurrogate = null
+  var bytes = []
+  var i = 0
+
+  for (; i < length; i++) {
+    codePoint = string.charCodeAt(i)
+
+    // is surrogate component
+    if (codePoint > 0xD7FF && codePoint < 0xE000) {
+      // last char was a lead
+      if (leadSurrogate) {
+        // 2 leads in a row
+        if (codePoint < 0xDC00) {
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          leadSurrogate = codePoint
+          continue
+        } else {
+          // valid surrogate pair
+          codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000
+          leadSurrogate = null
+        }
+      } else {
+        // no lead yet
+
+        if (codePoint > 0xDBFF) {
+          // unexpected trail
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        } else if (i + 1 === length) {
+          // unpaired lead
+          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+          continue
+        } else {
+          // valid lead
+          leadSurrogate = codePoint
+          continue
+        }
+      }
+    } else if (leadSurrogate) {
+      // valid bmp char, but last char was a lead
+      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+      leadSurrogate = null
+    }
+
+    // encode utf8
+    if (codePoint < 0x80) {
+      if ((units -= 1) < 0) break
+      bytes.push(codePoint)
+    } else if (codePoint < 0x800) {
+      if ((units -= 2) < 0) break
+      bytes.push(
+        codePoint >> 0x6 | 0xC0,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x10000) {
+      if ((units -= 3) < 0) break
+      bytes.push(
+        codePoint >> 0xC | 0xE0,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else if (codePoint < 0x200000) {
+      if ((units -= 4) < 0) break
+      bytes.push(
+        codePoint >> 0x12 | 0xF0,
+        codePoint >> 0xC & 0x3F | 0x80,
+        codePoint >> 0x6 & 0x3F | 0x80,
+        codePoint & 0x3F | 0x80
+      )
+    } else {
+      throw new Error('Invalid code point')
+    }
+  }
+
+  return bytes
+}
+
+function asciiToBytes (str) {
+  var byteArray = []
+  for (var i = 0; i < str.length; i++) {
+    // Node's code seems to be doing this and not & 0x7F..
+    byteArray.push(str.charCodeAt(i) & 0xFF)
+  }
+  return byteArray
+}
+
+function utf16leToBytes (str, units) {
+  var c, hi, lo
+  var byteArray = []
+  for (var i = 0; i < str.length; i++) {
+    if ((units -= 2) < 0) break
+
+    c = str.charCodeAt(i)
+    hi = c >> 8
+    lo = c % 256
+    byteArray.push(lo)
+    byteArray.push(hi)
+  }
+
+  return byteArray
+}
+
+function base64ToBytes (str) {
+  return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+  for (var i = 0; i < length; i++) {
+    if ((i + offset >= dst.length) || (i >= src.length))
+      break
+    dst[i + offset] = src[i]
+  }
+  return i
+}
+
+function decodeUtf8Char (str) {
+  try {
+    return decodeURIComponent(str)
+  } catch (err) {
+    return String.fromCharCode(0xFFFD) // UTF 8 invalid char
+  }
+}
+
+},{"base64-js":140,"ieee754":141,"is-array":142}],140:[function(require,module,exports){
+var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+;(function (exports) {
+	'use strict';
+
+  var Arr = (typeof Uint8Array !== 'undefined')
+    ? Uint8Array
+    : Array
+
+	var PLUS   = '+'.charCodeAt(0)
+	var SLASH  = '/'.charCodeAt(0)
+	var NUMBER = '0'.charCodeAt(0)
+	var LOWER  = 'a'.charCodeAt(0)
+	var UPPER  = 'A'.charCodeAt(0)
+	var PLUS_URL_SAFE = '-'.charCodeAt(0)
+	var SLASH_URL_SAFE = '_'.charCodeAt(0)
+
+	function decode (elt) {
+		var code = elt.charCodeAt(0)
+		if (code === PLUS ||
+		    code === PLUS_URL_SAFE)
+			return 62 // '+'
+		if (code === SLASH ||
+		    code === SLASH_URL_SAFE)
+			return 63 // '/'
+		if (code < NUMBER)
+			return -1 //no match
+		if (code < NUMBER + 10)
+			return code - NUMBER + 26 + 26
+		if (code < UPPER + 26)
+			return code - UPPER
+		if (code < LOWER + 26)
+			return code - LOWER + 26
+	}
+
+	function b64ToByteArray (b64) {
+		var i, j, l, tmp, placeHolders, arr
+
+		if (b64.length % 4 > 0) {
+			throw new Error('Invalid string. Length must be a multiple of 4')
+		}
+
+		// the number of equal signs (place holders)
+		// if there are two placeholders, than the two characters before it
+		// represent one byte
+		// if there is only one, then the three characters before it represent 2 bytes
+		// this is just a cheap hack to not do indexOf twice
+		var len = b64.length
+		placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
+
+		// base64 is 4/3 + up to two characters of the original data
+		arr = new Arr(b64.length * 3 / 4 - placeHolders)
+
+		// if there are placeholders, only get up to the last complete 4 chars
+		l = placeHolders > 0 ? b64.length - 4 : b64.length
+
+		var L = 0
+
+		function push (v) {
+			arr[L++] = v
+		}
+
+		for (i = 0, j = 0; i < l; i += 4, j += 3) {
+			tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
+			push((tmp & 0xFF0000) >> 16)
+			push((tmp & 0xFF00) >> 8)
+			push(tmp & 0xFF)
+		}
+
+		if (placeHolders === 2) {
+			tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
+			push(tmp & 0xFF)
+		} else if (placeHolders === 1) {
+			tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
+			push((tmp >> 8) & 0xFF)
+			push(tmp & 0xFF)
+		}
+
+		return arr
+	}
+
+	function uint8ToBase64 (uint8) {
+		var i,
+			extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+			output = "",
+			temp, length
+
+		function encode (num) {
+			return lookup.charAt(num)
+		}
+
+		function tripletToBase64 (num) {
+			return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
+		}
+
+		// go through the array every three bytes, we'll deal with trailing stuff later
+		for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+			temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+			output += tripletToBase64(temp)
+		}
+
+		// pad the end with zeros, but make sure to not forget the extra bytes
+		switch (extraBytes) {
+			case 1:
+				temp = uint8[uint8.length - 1]
+				output += encode(temp >> 2)
+				output += encode((temp << 4) & 0x3F)
+				output += '=='
+				break
+			case 2:
+				temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
+				output += encode(temp >> 10)
+				output += encode((temp >> 4) & 0x3F)
+				output += encode((temp << 2) & 0x3F)
+				output += '='
+				break
+		}
+
+		return output
+	}
+
+	exports.toByteArray = b64ToByteArray
+	exports.fromByteArray = uint8ToBase64
+}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
+
+},{}],141:[function(require,module,exports){
+exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+  var e, m,
+      eLen = nBytes * 8 - mLen - 1,
+      eMax = (1 << eLen) - 1,
+      eBias = eMax >> 1,
+      nBits = -7,
+      i = isLE ? (nBytes - 1) : 0,
+      d = isLE ? -1 : 1,
+      s = buffer[offset + i];
+
+  i += d;
+
+  e = s & ((1 << (-nBits)) - 1);
+  s >>= (-nBits);
+  nBits += eLen;
+  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+  m = e & ((1 << (-nBits)) - 1);
+  e >>= (-nBits);
+  nBits += mLen;
+  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+  if (e === 0) {
+    e = 1 - eBias;
+  } else if (e === eMax) {
+    return m ? NaN : ((s ? -1 : 1) * Infinity);
+  } else {
+    m = m + Math.pow(2, mLen);
+    e = e - eBias;
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+
+exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+  var e, m, c,
+      eLen = nBytes * 8 - mLen - 1,
+      eMax = (1 << eLen) - 1,
+      eBias = eMax >> 1,
+      rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
+      i = isLE ? 0 : (nBytes - 1),
+      d = isLE ? 1 : -1,
+      s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+  value = Math.abs(value);
+
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0;
+    e = eMax;
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2);
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--;
+      c *= 2;
+    }
+    if (e + eBias >= 1) {
+      value += rt / c;
+    } else {
+      value += rt * Math.pow(2, 1 - eBias);
+    }
+    if (value * c >= 2) {
+      e++;
+      c /= 2;
+    }
+
+    if (e + eBias >= eMax) {
+      m = 0;
+      e = eMax;
+    } else if (e + eBias >= 1) {
+      m = (value * c - 1) * Math.pow(2, mLen);
+      e = e + eBias;
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+      e = 0;
+    }
+  }
+
+  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
+
+  e = (e << mLen) | m;
+  eLen += mLen;
+  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
+
+  buffer[offset + i - d] |= s * 128;
+};
+
+},{}],142:[function(require,module,exports){
+
+/**
+ * isArray
+ */
+
+var isArray = Array.isArray;
+
+/**
+ * toString
+ */
+
+var str = Object.prototype.toString;
+
+/**
+ * Whether or not the given `val`
+ * is an array.
+ *
+ * example:
+ *
+ *        isArray([]);
+ *        // > true
+ *        isArray(arguments);
+ *        // > false
+ *        isArray('');
+ *        // > false
+ *
+ * @param {mixed} val
+ * @return {bool}
+ */
+
+module.exports = isArray || function (val) {
+  return !! val && '[object Array]' == str.call(val);
+};
+
+},{}],143:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!isNumber(n) || n < 0 || isNaN(n))
+    throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+  var er, handler, len, args, i, listeners;
+
+  if (!this._events)
+    this._events = {};
+
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error ||
+        (isObject(this._events.error) && !this._events.error.length)) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      }
+      throw TypeError('Uncaught, unspecified "error" event.');
+    }
+  }
+
+  handler = this._events[type];
+
+  if (isUndefined(handler))
+    return false;
+
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        len = arguments.length;
+        args = new Array(len - 1);
+        for (i = 1; i < len; i++)
+          args[i - 1] = arguments[i];
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    len = arguments.length;
+    args = new Array(len - 1);
+    for (i = 1; i < len; i++)
+      args[i - 1] = arguments[i];
+
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++)
+      listeners[i].apply(this, args);
+  }
+
+  return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  var m;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events)
+    this._events = {};
+
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener)
+    this.emit('newListener', type,
+              isFunction(listener.listener) ?
+              listener.listener : listener);
+
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    var m;
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
+
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' +
+                    'leak detected. %d listeners added. ' +
+                    'Use emitter.setMaxListeners() to increase limit.',
+                    this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  var fired = false;
+
+  function g() {
+    this.removeListener(type, g);
+
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
+
+  g.listener = listener;
+  this.on(type, g);
+
+  return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var list, position, length, i;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events || !this._events[type])
+    return this;
+
+  list = this._events[type];
+  length = list.length;
+  position = -1;
+
+  if (list === listener ||
+      (isFunction(list.listener) && list.listener === listener)) {
+    delete this._events[type];
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener)) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0)
+      return this;
+
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  var key, listeners;
+
+  if (!this._events)
+    return this;
+
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0)
+      this._events = {};
+    else if (this._events[type])
+      delete this._events[type];
+    return this;
+  }
+
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else {
+    // LIFO order
+    while (listeners.length)
+      this.removeListener(type, listeners[listeners.length - 1]);
+  }
+  delete this._events[type];
+
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  var ret;
+  if (!this._events || !this._events[type])
+    ret = [];
+  else if (isFunction(this._events[type]))
+    ret = [this._events[type]];
+  else
+    ret = this._events[type].slice();
+  return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  var ret;
+  if (!emitter._events || !emitter._events[type])
+    ret = 0;
+  else if (isFunction(emitter._events[type]))
+    ret = 1;
+  else
+    ret = emitter._events[type].length;
+  return ret;
+};
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+
+},{}],144:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor
+    var TempCtor = function () {}
+    TempCtor.prototype = superCtor.prototype
+    ctor.prototype = new TempCtor()
+    ctor.prototype.constructor = ctor
+  }
+}
+
+},{}],145:[function(require,module,exports){
+module.exports = Array.isArray || function (arr) {
+  return Object.prototype.toString.call(arr) == '[object Array]';
+};
+
+},{}],146:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+  // if the path tries to go above the root, `up` ends up > 0
+  var up = 0;
+  for (var i = parts.length - 1; i >= 0; i--) {
+    var last = parts[i];
+    if (last === '.') {
+      parts.splice(i, 1);
+    } else if (last === '..') {
+      parts.splice(i, 1);
+      up++;
+    } else if (up) {
+      parts.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (allowAboveRoot) {
+    for (; up--; up) {
+      parts.unshift('..');
+    }
+  }
+
+  return parts;
+}
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var splitPath = function(filename) {
+  return splitPathRe.exec(filename).slice(1);
+};
+
+// path.resolve([from ...], to)
+// posix version
+exports.resolve = function() {
+  var resolvedPath = '',
+      resolvedAbsolute = false;
+
+  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    var path = (i >= 0) ? arguments[i] : process.cwd();
+
+    // Skip empty and invalid entries
+    if (typeof path !== 'string') {
+      throw new TypeError('Arguments to path.resolve must be strings');
+    } else if (!path) {
+      continue;
+    }
+
+    resolvedPath = path + '/' + resolvedPath;
+    resolvedAbsolute = path.charAt(0) === '/';
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
+    return !!p;
+  }), !resolvedAbsolute).join('/');
+
+  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+};
+
+// path.normalize(path)
+// posix version
+exports.normalize = function(path) {
+  var isAbsolute = exports.isAbsolute(path),
+      trailingSlash = substr(path, -1) === '/';
+
+  // Normalize the path
+  path = normalizeArray(filter(path.split('/'), function(p) {
+    return !!p;
+  }), !isAbsolute).join('/');
+
+  if (!path && !isAbsolute) {
+    path = '.';
+  }
+  if (path && trailingSlash) {
+    path += '/';
+  }
+
+  return (isAbsolute ? '/' : '') + path;
+};
+
+// posix version
+exports.isAbsolute = function(path) {
+  return path.charAt(0) === '/';
+};
+
+// posix version
+exports.join = function() {
+  var paths = Array.prototype.slice.call(arguments, 0);
+  return exports.normalize(filter(paths, function(p, index) {
+    if (typeof p !== 'string') {
+      throw new TypeError('Arguments to path.join must be strings');
+    }
+    return p;
+  }).join('/'));
+};
+
+
+// path.relative(from, to)
+// posix version
+exports.relative = function(from, to) {
+  from = exports.resolve(from).substr(1);
+  to = exports.resolve(to).substr(1);
+
+  function trim(arr) {
+    var start = 0;
+    for (; start < arr.length; start++) {
+      if (arr[start] !== '') break;
+    }
+
+    var end = arr.length - 1;
+    for (; end >= 0; end--) {
+      if (arr[end] !== '') break;
+    }
+
+    if (start > end) return [];
+    return arr.slice(start, end - start + 1);
+  }
+
+  var fromParts = trim(from.split('/'));
+  var toParts = trim(to.split('/'));
+
+  var length = Math.min(fromParts.length, toParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  var outputParts = [];
+  for (var i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push('..');
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join('/');
+};
+
+exports.sep = '/';
+exports.delimiter = ':';
+
+exports.dirname = function(path) {
+  var result = splitPath(path),
+      root = result[0],
+      dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+};
+
+
+exports.basename = function(path, ext) {
+  var f = splitPath(path)[2];
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+
+exports.extname = function(path) {
+  return splitPath(path)[3];
+};
+
+function filter (xs, f) {
+    if (xs.filter) return xs.filter(f);
+    var res = [];
+    for (var i = 0; i < xs.length; i++) {
+        if (f(xs[i], i, xs)) res.push(xs[i]);
+    }
+    return res;
+}
+
+// String.prototype.substr - negative index don't work in IE8
+var substr = 'ab'.substr(-1) === 'b'
+    ? function (str, start, len) { return str.substr(start, len) }
+    : function (str, start, len) {
+        if (start < 0) start = str.length + start;
+        return str.substr(start, len);
+    }
+;
+
+}).call(this,require('_process'))
+},{"_process":147}],147:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+var queue = [];
+var draining = false;
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    draining = true;
+    var currentQueue;
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        var i = -1;
+        while (++i < len) {
+            currentQueue[i]();
+        }
+        len = queue.length;
+    }
+    draining = false;
+}
+process.nextTick = function (fun) {
+    queue.push(fun);
+    if (!draining) {
+        setTimeout(drainQueue, 0);
+    }
+};
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+},{}],148:[function(require,module,exports){
+module.exports = require("./lib/_stream_duplex.js")
+
+},{"./lib/_stream_duplex.js":149}],149:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) keys.push(key);
+  return keys;
+}
+/*</replacement>*/
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+forEach(objectKeys(Writable.prototype), function(method) {
+  if (!Duplex.prototype[method])
+    Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+  if (!(this instanceof Duplex))
+    return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false)
+    this.readable = false;
+
+  if (options && options.writable === false)
+    this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false)
+    this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended)
+    return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  process.nextTick(this.end.bind(this));
+}
+
+function forEach (xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+
+}).call(this,require('_process'))
+},{"./_stream_readable":151,"./_stream_writable":153,"_process":147,"core-util-is":154,"inherits":144}],150:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough))
+    return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+  cb(null, chunk);
+};
+
+},{"./_stream_transform":152,"core-util-is":154,"inherits":144}],151:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+
+/*<replacement>*/
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+  return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+var Stream = require('stream');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+  options = options || {};
+
+  // the point at which it stops calling _read() to fill the buffer
+  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  var hwm = options.highWaterMark;
+  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+  // cast to ints.
+  this.highWaterMark = ~~this.highWaterMark;
+
+  this.buffer = [];
+  this.length = 0;
+  this.pipes = null;
+  this.pipesCount = 0;
+  this.flowing = false;
+  this.ended = false;
+  this.endEmitted = false;
+  this.reading = false;
+
+  // In streams that never have any data, and do push(null) right away,
+  // the consumer can miss the 'end' event if they do some I/O before
+  // consuming the stream.  So, we don't emit('end') until some reading
+  // happens.
+  this.calledRead = false;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, becuase any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // whenever we return null, then we set a flag to say
+  // that we're awaiting a 'readable' event emission.
+  this.needReadable = false;
+  this.emittedReadable = false;
+  this.readableListening = false;
+
+
+  // object stream flag. Used to make read(n) ignore n and to
+  // make all the buffer merging and length checks go away
+  this.objectMode = !!options.objectMode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // when piping, we only care about 'readable' events that happen
+  // after read()ing all the bytes and not getting any pushback.
+  this.ranOut = false;
+
+  // the number of writers that are awaiting a drain event in .pipe()s
+  this.awaitDrain = 0;
+
+  // if true, a maybeReadMore has been scheduled
+  this.readingMore = false;
+
+  this.decoder = null;
+  this.encoding = null;
+  if (options.encoding) {
+    if (!StringDecoder)
+      StringDecoder = require('string_decoder/').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+function Readable(options) {
+  if (!(this instanceof Readable))
+    return new Readable(options);
+
+  this._readableState = new ReadableState(options, this);
+
+  // legacy
+  this.readable = true;
+
+  Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+  var state = this._readableState;
+
+  if (typeof chunk === 'string' && !state.objectMode) {
+    encoding = encoding || state.defaultEncoding;
+    if (encoding !== state.encoding) {
+      chunk = new Buffer(chunk, encoding);
+      encoding = '';
+    }
+  }
+
+  return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+  var state = this._readableState;
+  return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+  var er = chunkInvalid(state, chunk);
+  if (er) {
+    stream.emit('error', er);
+  } else if (chunk === null || chunk === undefined) {
+    state.reading = false;
+    if (!state.ended)
+      onEofChunk(stream, state);
+  } else if (state.objectMode || chunk && chunk.length > 0) {
+    if (state.ended && !addToFront) {
+      var e = new Error('stream.push() after EOF');
+      stream.emit('error', e);
+    } else if (state.endEmitted && addToFront) {
+      var e = new Error('stream.unshift() after end event');
+      stream.emit('error', e);
+    } else {
+      if (state.decoder && !addToFront && !encoding)
+        chunk = state.decoder.write(chunk);
+
+      // update the buffer info.
+      state.length += state.objectMode ? 1 : chunk.length;
+      if (addToFront) {
+        state.buffer.unshift(chunk);
+      } else {
+        state.reading = false;
+        state.buffer.push(chunk);
+      }
+
+      if (state.needReadable)
+        emitReadable(stream);
+
+      maybeReadMore(stream, state);
+    }
+  } else if (!addToFront) {
+    state.reading = false;
+  }
+
+  return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes.  This is to work around cases where hwm=0,
+// such as the repl.  Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+  return !state.ended &&
+         (state.needReadable ||
+          state.length < state.highWaterMark ||
+          state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+  if (!StringDecoder)
+    StringDecoder = require('string_decoder/').StringDecoder;
+  this._readableState.decoder = new StringDecoder(enc);
+  this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+  if (n >= MAX_HWM) {
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2
+    n--;
+    for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+    n++;
+  }
+  return n;
+}
+
+function howMuchToRead(n, state) {
+  if (state.length === 0 && state.ended)
+    return 0;
+
+  if (state.objectMode)
+    return n === 0 ? 0 : 1;
+
+  if (n === null || isNaN(n)) {
+    // only flow one buffer at a time
+    if (state.flowing && state.buffer.length)
+      return state.buffer[0].length;
+    else
+      return state.length;
+  }
+
+  if (n <= 0)
+    return 0;
+
+  // If we're asking for more than the target buffer level,
+  // then raise the water mark.  Bump up to the next highest
+  // power of 2, to prevent increasing it excessively in tiny
+  // amounts.
+  if (n > state.highWaterMark)
+    state.highWaterMark = roundUpToNextPowerOf2(n);
+
+  // don't have that much.  return null, unless we've ended.
+  if (n > state.length) {
+    if (!state.ended) {
+      state.needReadable = true;
+      return 0;
+    } else
+      return state.length;
+  }
+
+  return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+  var state = this._readableState;
+  state.calledRead = true;
+  var nOrig = n;
+  var ret;
+
+  if (typeof n !== 'number' || n > 0)
+    state.emittedReadable = false;
+
+  // if we're doing read(0) to trigger a readable event, but we
+  // already have a bunch of data in the buffer, then just trigger
+  // the 'readable' event and move on.
+  if (n === 0 &&
+      state.needReadable &&
+      (state.length >= state.highWaterMark || state.ended)) {
+    emitReadable(this);
+    return null;
+  }
+
+  n = howMuchToRead(n, state);
+
+  // if we've ended, and we're now clear, then finish it up.
+  if (n === 0 && state.ended) {
+    ret = null;
+
+    // In cases where the decoder did not receive enough data
+    // to produce a full chunk, then immediately received an
+    // EOF, state.buffer will contain [<Buffer >, <Buffer 00 ...>].
+    // howMuchToRead will see this and coerce the amount to
+    // read to zero (because it's looking at the length of the
+    // first <Buffer > in state.buffer), and we'll end up here.
+    //
+    // This can only happen via state.decoder -- no other venue
+    // exists for pushing a zero-length chunk into state.buffer
+    // and triggering this behavior. In this case, we return our
+    // remaining data and end the stream, if appropriate.
+    if (state.length > 0 && state.decoder) {
+      ret = fromList(n, state);
+      state.length -= ret.length;
+    }
+
+    if (state.length === 0)
+      endReadable(this);
+
+    return ret;
+  }
+
+  // All the actual chunk generation logic needs to be
+  // *below* the call to _read.  The reason is that in certain
+  // synthetic stream cases, such as passthrough streams, _read
+  // may be a completely synchronous operation which may change
+  // the state of the read buffer, providing enough data when
+  // before there was *not* enough.
+  //
+  // So, the steps are:
+  // 1. Figure out what the state of things will be after we do
+  // a read from the buffer.
+  //
+  // 2. If that resulting state will trigger a _read, then call _read.
+  // Note that this may be asynchronous, or synchronous.  Yes, it is
+  // deeply ugly to write APIs this way, but that still doesn't mean
+  // that the Readable class should behave improperly, as streams are
+  // designed to be sync/async agnostic.
+  // Take note if the _read call is sync or async (ie, if the read call
+  // has returned yet), so that we know whether or not it's safe to emit
+  // 'readable' etc.
+  //
+  // 3. Actually pull the requested chunks out of the buffer and return.
+
+  // if we need a readable event, then we need to do some reading.
+  var doRead = state.needReadable;
+
+  // if we currently have less than the highWaterMark, then also read some
+  if (state.length - n <= state.highWaterMark)
+    doRead = true;
+
+  // however, if we've ended, then there's no point, and if we're already
+  // reading, then it's unnecessary.
+  if (state.ended || state.reading)
+    doRead = false;
+
+  if (doRead) {
+    state.reading = true;
+    state.sync = true;
+    // if the length is currently zero, then we *need* a readable event.
+    if (state.length === 0)
+      state.needReadable = true;
+    // call internal read method
+    this._read(state.highWaterMark);
+    state.sync = false;
+  }
+
+  // If _read called its callback synchronously, then `reading`
+  // will be false, and we need to re-evaluate how much data we
+  // can return to the user.
+  if (doRead && !state.reading)
+    n = howMuchToRead(nOrig, state);
+
+  if (n > 0)
+    ret = fromList(n, state);
+  else
+    ret = null;
+
+  if (ret === null) {
+    state.needReadable = true;
+    n = 0;
+  }
+
+  state.length -= n;
+
+  // If we have nothing in the buffer, then we want to know
+  // as soon as we *do* get something into the buffer.
+  if (state.length === 0 && !state.ended)
+    state.needReadable = true;
+
+  // If we happened to read() exactly the remaining amount in the
+  // buffer, and the EOF has been seen at this point, then make sure
+  // that we emit 'end' on the very next tick.
+  if (state.ended && !state.endEmitted && state.length === 0)
+    endReadable(this);
+
+  return ret;
+};
+
+function chunkInvalid(state, chunk) {
+  var er = null;
+  if (!Buffer.isBuffer(chunk) &&
+      'string' !== typeof chunk &&
+      chunk !== null &&
+      chunk !== undefined &&
+      !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  return er;
+}
+
+
+function onEofChunk(stream, state) {
+  if (state.decoder && !state.ended) {
+    var chunk = state.decoder.end();
+    if (chunk && chunk.length) {
+      state.buffer.push(chunk);
+      state.length += state.objectMode ? 1 : chunk.length;
+    }
+  }
+  state.ended = true;
+
+  // if we've ended and we have some data left, then emit
+  // 'readable' now to make sure it gets picked up.
+  if (state.length > 0)
+    emitReadable(stream);
+  else
+    endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+  var state = stream._readableState;
+  state.needReadable = false;
+  if (state.emittedReadable)
+    return;
+
+  state.emittedReadable = true;
+  if (state.sync)
+    process.nextTick(function() {
+      emitReadable_(stream);
+    });
+  else
+    emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+  stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data.  that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+  if (!state.readingMore) {
+    state.readingMore = true;
+    process.nextTick(function() {
+      maybeReadMore_(stream, state);
+    });
+  }
+}
+
+function maybeReadMore_(stream, state) {
+  var len = state.length;
+  while (!state.reading && !state.flowing && !state.ended &&
+         state.length < state.highWaterMark) {
+    stream.read(0);
+    if (len === state.length)
+      // didn't get any data, stop spinning.
+      break;
+    else
+      len = state.length;
+  }
+  state.readingMore = false;
+}
+
+// abstract method.  to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+  this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+  var src = this;
+  var state = this._readableState;
+
+  switch (state.pipesCount) {
+    case 0:
+      state.pipes = dest;
+      break;
+    case 1:
+      state.pipes = [state.pipes, dest];
+      break;
+    default:
+      state.pipes.push(dest);
+      break;
+  }
+  state.pipesCount += 1;
+
+  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+              dest !== process.stdout &&
+              dest !== process.stderr;
+
+  var endFn = doEnd ? onend : cleanup;
+  if (state.endEmitted)
+    process.nextTick(endFn);
+  else
+    src.once('end', endFn);
+
+  dest.on('unpipe', onunpipe);
+  function onunpipe(readable) {
+    if (readable !== src) return;
+    cleanup();
+  }
+
+  function onend() {
+    dest.end();
+  }
+
+  // when the dest drains, it reduces the awaitDrain counter
+  // on the source.  This would be more elegant with a .once()
+  // handler in flow(), but adding and removing repeatedly is
+  // too slow.
+  var ondrain = pipeOnDrain(src);
+  dest.on('drain', ondrain);
+
+  function cleanup() {
+    // cleanup event handlers once the pipe is broken
+    dest.removeListener('close', onclose);
+    dest.removeListener('finish', onfinish);
+    dest.removeListener('drain', ondrain);
+    dest.removeListener('error', onerror);
+    dest.removeListener('unpipe', onunpipe);
+    src.removeListener('end', onend);
+    src.removeListener('end', cleanup);
+
+    // if the reader is waiting for a drain event from this
+    // specific writer, then it would cause it to never start
+    // flowing again.
+    // So, if this is awaiting a drain, then we just call it now.
+    // If we don't know, then assume that we are waiting for one.
+    if (!dest._writableState || dest._writableState.needDrain)
+      ondrain();
+  }
+
+  // if the dest has an error, then stop piping into it.
+  // however, don't suppress the throwing behavior for this.
+  function onerror(er) {
+    unpipe();
+    dest.removeListener('error', onerror);
+    if (EE.listenerCount(dest, 'error') === 0)
+      dest.emit('error', er);
+  }
+  // This is a brutally ugly hack to make sure that our error handler
+  // is attached before any userland ones.  NEVER DO THIS.
+  if (!dest._events || !dest._events.error)
+    dest.on('error', onerror);
+  else if (isArray(dest._events.error))
+    dest._events.error.unshift(onerror);
+  else
+    dest._events.error = [onerror, dest._events.error];
+
+
+
+  // Both close and finish should trigger unpipe, but only once.
+  function onclose() {
+    dest.removeListener('finish', onfinish);
+    unpipe();
+  }
+  dest.once('close', onclose);
+  function onfinish() {
+    dest.removeListener('close', onclose);
+    unpipe();
+  }
+  dest.once('finish', onfinish);
+
+  function unpipe() {
+    src.unpipe(dest);
+  }
+
+  // tell the dest that it's being piped to
+  dest.emit('pipe', src);
+
+  // start the flow if it hasn't been started already.
+  if (!state.flowing) {
+    // the handler that waits for readable events after all
+    // the data gets sucked out in flow.
+    // This would be easier to follow with a .once() handler
+    // in flow(), but that is too slow.
+    this.on('readable', pipeOnReadable);
+
+    state.flowing = true;
+    process.nextTick(function() {
+      flow(src);
+    });
+  }
+
+  return dest;
+};
+
+function pipeOnDrain(src) {
+  return function() {
+    var dest = this;
+    var state = src._readableState;
+    state.awaitDrain--;
+    if (state.awaitDrain === 0)
+      flow(src);
+  };
+}
+
+function flow(src) {
+  var state = src._readableState;
+  var chunk;
+  state.awaitDrain = 0;
+
+  function write(dest, i, list) {
+    var written = dest.write(chunk);
+    if (false === written) {
+      state.awaitDrain++;
+    }
+  }
+
+  while (state.pipesCount && null !== (chunk = src.read())) {
+
+    if (state.pipesCount === 1)
+      write(state.pipes, 0, null);
+    else
+      forEach(state.pipes, write);
+
+    src.emit('data', chunk);
+
+    // if anyone needs a drain, then we have to wait for that.
+    if (state.awaitDrain > 0)
+      return;
+  }
+
+  // if every destination was unpiped, either before entering this
+  // function, or in the while loop, then stop flowing.
+  //
+  // NB: This is a pretty rare edge case.
+  if (state.pipesCount === 0) {
+    state.flowing = false;
+
+    // if there were data event listeners added, then switch to old mode.
+    if (EE.listenerCount(src, 'data') > 0)
+      emitDataEvents(src);
+    return;
+  }
+
+  // at this point, no one needed a drain, so we just ran out of data
+  // on the next readable event, start it over again.
+  state.ranOut = true;
+}
+
+function pipeOnReadable() {
+  if (this._readableState.ranOut) {
+    this._readableState.ranOut = false;
+    flow(this);
+  }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+  var state = this._readableState;
+
+  // if we're not piping anywhere, then do nothing.
+  if (state.pipesCount === 0)
+    return this;
+
+  // just one destination.  most common case.
+  if (state.pipesCount === 1) {
+    // passed in one, but it's not the right one.
+    if (dest && dest !== state.pipes)
+      return this;
+
+    if (!dest)
+      dest = state.pipes;
+
+    // got a match.
+    state.pipes = null;
+    state.pipesCount = 0;
+    this.removeListener('readable', pipeOnReadable);
+    state.flowing = false;
+    if (dest)
+      dest.emit('unpipe', this);
+    return this;
+  }
+
+  // slow case. multiple pipe destinations.
+
+  if (!dest) {
+    // remove all.
+    var dests = state.pipes;
+    var len = state.pipesCount;
+    state.pipes = null;
+    state.pipesCount = 0;
+    this.removeListener('readable', pipeOnReadable);
+    state.flowing = false;
+
+    for (var i = 0; i < len; i++)
+      dests[i].emit('unpipe', this);
+    return this;
+  }
+
+  // try to find the right one.
+  var i = indexOf(state.pipes, dest);
+  if (i === -1)
+    return this;
+
+  state.pipes.splice(i, 1);
+  state.pipesCount -= 1;
+  if (state.pipesCount === 1)
+    state.pipes = state.pipes[0];
+
+  dest.emit('unpipe', this);
+
+  return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+  var res = Stream.prototype.on.call(this, ev, fn);
+
+  if (ev === 'data' && !this._readableState.flowing)
+    emitDataEvents(this);
+
+  if (ev === 'readable' && this.readable) {
+    var state = this._readableState;
+    if (!state.readableListening) {
+      state.readableListening = true;
+      state.emittedReadable = false;
+      state.needReadable = true;
+      if (!state.reading) {
+        this.read(0);
+      } else if (state.length) {
+        emitReadable(this, state);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+  emitDataEvents(this);
+  this.read(0);
+  this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+  emitDataEvents(this, true);
+  this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+  var state = stream._readableState;
+
+  if (state.flowing) {
+    // https://github.com/isaacs/readable-stream/issues/16
+    throw new Error('Cannot switch to old mode now.');
+  }
+
+  var paused = startPaused || false;
+  var readable = false;
+
+  // convert to an old-style stream.
+  stream.readable = true;
+  stream.pipe = Stream.prototype.pipe;
+  stream.on = stream.addListener = Stream.prototype.on;
+
+  stream.on('readable', function() {
+    readable = true;
+
+    var c;
+    while (!paused && (null !== (c = stream.read())))
+      stream.emit('data', c);
+
+    if (c === null) {
+      readable = false;
+      stream._readableState.needReadable = true;
+    }
+  });
+
+  stream.pause = function() {
+    paused = true;
+    this.emit('pause');
+  };
+
+  stream.resume = function() {
+    paused = false;
+    if (readable)
+      process.nextTick(function() {
+        stream.emit('readable');
+      });
+    else
+      this.read(0);
+    this.emit('resume');
+  };
+
+  // now make it start, just in case it hadn't already.
+  stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+  var state = this._readableState;
+  var paused = false;
+
+  var self = this;
+  stream.on('end', function() {
+    if (state.decoder && !state.ended) {
+      var chunk = state.decoder.end();
+      if (chunk && chunk.length)
+        self.push(chunk);
+    }
+
+    self.push(null);
+  });
+
+  stream.on('data', function(chunk) {
+    if (state.decoder)
+      chunk = state.decoder.write(chunk);
+
+    // don't skip over falsy values in objectMode
+    //if (state.objectMode && util.isNullOrUndefined(chunk))
+    if (state.objectMode && (chunk === null || chunk === undefined))
+      return;
+    else if (!state.objectMode && (!chunk || !chunk.length))
+      return;
+
+    var ret = self.push(chunk);
+    if (!ret) {
+      paused = true;
+      stream.pause();
+    }
+  });
+
+  // proxy all the other methods.
+  // important when wrapping filters and duplexes.
+  for (var i in stream) {
+    if (typeof stream[i] === 'function' &&
+        typeof this[i] === 'undefined') {
+      this[i] = function(method) { return function() {
+        return stream[method].apply(stream, arguments);
+      }}(i);
+    }
+  }
+
+  // proxy certain important events.
+  var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+  forEach(events, function(ev) {
+    stream.on(ev, self.emit.bind(self, ev));
+  });
+
+  // when we try to consume some more bytes, simply unpause the
+  // underlying stream.
+  self._read = function(n) {
+    if (paused) {
+      paused = false;
+      stream.resume();
+    }
+  };
+
+  return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+  var list = state.buffer;
+  var length = state.length;
+  var stringMode = !!state.decoder;
+  var objectMode = !!state.objectMode;
+  var ret;
+
+  // nothing in the list, definitely empty.
+  if (list.length === 0)
+    return null;
+
+  if (length === 0)
+    ret = null;
+  else if (objectMode)
+    ret = list.shift();
+  else if (!n || n >= length) {
+    // read it all, truncate the array.
+    if (stringMode)
+      ret = list.join('');
+    else
+      ret = Buffer.concat(list, length);
+    list.length = 0;
+  } else {
+    // read just some of it.
+    if (n < list[0].length) {
+      // just take a part of the first list item.
+      // slice is the same for buffers and strings.
+      var buf = list[0];
+      ret = buf.slice(0, n);
+      list[0] = buf.slice(n);
+    } else if (n === list[0].length) {
+      // first list is a perfect match
+      ret = list.shift();
+    } else {
+      // complex case.
+      // we have enough to cover it, but it spans past the first buffer.
+      if (stringMode)
+        ret = '';
+      else
+        ret = new Buffer(n);
+
+      var c = 0;
+      for (var i = 0, l = list.length; i < l && c < n; i++) {
+        var buf = list[0];
+        var cpy = Math.min(n - c, buf.length);
+
+        if (stringMode)
+          ret += buf.slice(0, cpy);
+        else
+          buf.copy(ret, c, 0, cpy);
+
+        if (cpy < buf.length)
+          list[0] = buf.slice(cpy);
+        else
+          list.shift();
+
+        c += cpy;
+      }
+    }
+  }
+
+  return ret;
+}
+
+function endReadable(stream) {
+  var state = stream._readableState;
+
+  // If we get here before consuming all the bytes, then that is a
+  // bug in node.  Should never happen.
+  if (state.length > 0)
+    throw new Error('endReadable called on non-empty stream');
+
+  if (!state.endEmitted && state.calledRead) {
+    state.ended = true;
+    process.nextTick(function() {
+      // Check that we didn't get one last unshift.
+      if (!state.endEmitted && state.length === 0) {
+        state.endEmitted = true;
+        stream.readable = false;
+        stream.emit('end');
+      }
+    });
+  }
+}
+
+function forEach (xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+
+function indexOf (xs, x) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    if (xs[i] === x) return i;
+  }
+  return -1;
+}
+
+}).call(this,require('_process'))
+},{"_process":147,"buffer":139,"core-util-is":154,"events":143,"inherits":144,"isarray":145,"stream":159,"string_decoder/":160}],152:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+  this.afterTransform = function(er, data) {
+    return afterTransform(stream, er, data);
+  };
+
+  this.needTransform = false;
+  this.transforming = false;
+  this.writecb = null;
+  this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+  var ts = stream._transformState;
+  ts.transforming = false;
+
+  var cb = ts.writecb;
+
+  if (!cb)
+    return stream.emit('error', new Error('no writecb in Transform class'));
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data !== null && data !== undefined)
+    stream.push(data);
+
+  if (cb)
+    cb(er);
+
+  var rs = stream._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    stream._read(rs.highWaterMark);
+  }
+}
+
+
+function Transform(options) {
+  if (!(this instanceof Transform))
+    return new Transform(options);
+
+  Duplex.call(this, options);
+
+  var ts = this._transformState = new TransformState(options, this);
+
+  // when the writable side finishes, then flush out anything remaining.
+  var stream = this;
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
+
+  // we have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  this.once('finish', function() {
+    if ('function' === typeof this._flush)
+      this._flush(function(er) {
+        done(stream, er);
+      });
+    else
+      done(stream);
+  });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+  this._transformState.needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+  throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+  var ts = this._transformState;
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    var rs = this._readableState;
+    if (ts.needTransform ||
+        rs.needReadable ||
+        rs.length < rs.highWaterMark)
+      this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+  var ts = this._transformState;
+
+  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+
+function done(stream, er) {
+  if (er)
+    return stream.emit('error', er);
+
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+  var ws = stream._writableState;
+  var rs = stream._readableState;
+  var ts = stream._transformState;
+
+  if (ws.length)
+    throw new Error('calling transform done when ws.length != 0');
+
+  if (ts.transforming)
+    throw new Error('calling transform done when still transforming');
+
+  return stream.push(null);
+}
+
+},{"./_stream_duplex":149,"core-util-is":154,"inherits":144}],153:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Stream = require('stream');
+
+util.inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+}
+
+function WritableState(options, stream) {
+  options = options || {};
+
+  // the point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write()
+  var hwm = options.highWaterMark;
+  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+  // object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+  this.objectMode = !!options.objectMode;
+
+  // cast to ints.
+  this.highWaterMark = ~~this.highWaterMark;
+
+  this.needDrain = false;
+  // at the start of calling end()
+  this.ending = false;
+  // when end() has been called, and returned
+  this.ended = false;
+  // when 'finish' is emitted
+  this.finished = false;
+
+  // should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+  var noDecode = options.decodeStrings === false;
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+  this.length = 0;
+
+  // a flag to see when we're in the middle of a write.
+  this.writing = false;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, becuase any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // a flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
+
+  // the callback that's passed to _write(chunk,cb)
+  this.onwrite = function(er) {
+    onwrite(stream, er);
+  };
+
+  // the callback that the user supplies to write(chunk,encoding,cb)
+  this.writecb = null;
+
+  // the amount that is being written when _write is called.
+  this.writelen = 0;
+
+  this.buffer = [];
+
+  // True if the error was already emitted and should not be thrown again
+  this.errorEmitted = false;
+}
+
+function Writable(options) {
+  var Duplex = require('./_stream_duplex');
+
+  // Writable ctor is applied to Duplexes, though they're not
+  // instanceof Writable, they're instanceof Readable.
+  if (!(this instanceof Writable) && !(this instanceof Duplex))
+    return new Writable(options);
+
+  this._writableState = new WritableState(options, this);
+
+  // legacy.
+  this.writable = true;
+
+  Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+  this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+  var er = new Error('write after end');
+  // TODO: defer error events consistently everywhere, not just the cb
+  stream.emit('error', er);
+  process.nextTick(function() {
+    cb(er);
+  });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+  var valid = true;
+  if (!Buffer.isBuffer(chunk) &&
+      'string' !== typeof chunk &&
+      chunk !== null &&
+      chunk !== undefined &&
+      !state.objectMode) {
+    var er = new TypeError('Invalid non-string/buffer chunk');
+    stream.emit('error', er);
+    process.nextTick(function() {
+      cb(er);
+    });
+    valid = false;
+  }
+  return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (Buffer.isBuffer(chunk))
+    encoding = 'buffer';
+  else if (!encoding)
+    encoding = state.defaultEncoding;
+
+  if (typeof cb !== 'function')
+    cb = function() {};
+
+  if (state.ended)
+    writeAfterEnd(this, state, cb);
+  else if (validChunk(this, state, chunk, cb))
+    ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+  return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode &&
+      state.decodeStrings !== false &&
+      typeof chunk === 'string') {
+    chunk = new Buffer(chunk, encoding);
+  }
+  return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+  chunk = decodeChunk(state, chunk, encoding);
+  if (Buffer.isBuffer(chunk))
+    encoding = 'buffer';
+  var len = state.objectMode ? 1 : chunk.length;
+
+  state.length += len;
+
+  var ret = state.length < state.highWaterMark;
+  // we must ensure that previous needDrain will not be reset to false.
+  if (!ret)
+    state.needDrain = true;
+
+  if (state.writing)
+    state.buffer.push(new WriteReq(chunk, encoding, cb));
+  else
+    doWrite(stream, state, len, chunk, encoding, cb);
+
+  return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+  if (sync)
+    process.nextTick(function() {
+      cb(er);
+    });
+  else
+    cb(er);
+
+  stream._writableState.errorEmitted = true;
+  stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+  var state = stream._writableState;
+  var sync = state.sync;
+  var cb = state.writecb;
+
+  onwriteStateUpdate(state);
+
+  if (er)
+    onwriteError(stream, state, sync, er, cb);
+  else {
+    // Check if we're actually ready to finish, but don't emit yet
+    var finished = needFinish(stream, state);
+
+    if (!finished && !state.bufferProcessing && state.buffer.length)
+      clearBuffer(stream, state);
+
+    if (sync) {
+      process.nextTick(function() {
+        afterWrite(stream, state, finished, cb);
+      });
+    } else {
+      afterWrite(stream, state, finished, cb);
+    }
+  }
+}
+
+function afterWrite(stream, state, finished, cb) {
+  if (!finished)
+    onwriteDrain(stream, state);
+  cb();
+  if (finished)
+    finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+  if (state.length === 0 && state.needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+  state.bufferProcessing = true;
+
+  for (var c = 0; c < state.buffer.length; c++) {
+    var entry = state.buffer[c];
+    var chunk = entry.chunk;
+    var encoding = entry.encoding;
+    var cb = entry.callback;
+    var len = state.objectMode ? 1 : chunk.length;
+
+    doWrite(stream, state, len, chunk, encoding, cb);
+
+    // if we didn't call the onwrite immediately, then
+    // it means that we need to wait until it does.
+    // also, that means that the chunk and cb are currently
+    // being processed, so move the buffer counter past them.
+    if (state.writing) {
+      c++;
+      break;
+    }
+  }
+
+  state.bufferProcessing = false;
+  if (c < state.buffer.length)
+    state.buffer = state.buffer.slice(c);
+  else
+    state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+  cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (typeof chunk !== 'undefined' && chunk !== null)
+    this.write(chunk, encoding);
+
+  // ignore unnecessary end() calls.
+  if (!state.ending && !state.finished)
+    endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+  return (state.ending &&
+          state.length === 0 &&
+          !state.finished &&
+          !state.writing);
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(stream, state);
+  if (need) {
+    state.finished = true;
+    stream.emit('finish');
+  }
+  return need;
+}
+
+function endWritable(stream, state, cb) {
+  state.ending = true;
+  finishMaybe(stream, state);
+  if (cb) {
+    if (state.finished)
+      process.nextTick(cb);
+    else
+      stream.once('finish', cb);
+  }
+  state.ended = true;
+}
+
+}).call(this,require('_process'))
+},{"./_stream_duplex":149,"_process":147,"buffer":139,"core-util-is":154,"inherits":144,"stream":159}],154:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+function isBuffer(arg) {
+  return Buffer.isBuffer(arg);
+}
+exports.isBuffer = isBuffer;
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+}).call(this,require("buffer").Buffer)
+},{"buffer":139}],155:[function(require,module,exports){
+module.exports = require("./lib/_stream_passthrough.js")
+
+},{"./lib/_stream_passthrough.js":150}],156:[function(require,module,exports){
+var Stream = require('stream'); // hack to fix a circular dependency issue when used with browserify
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = Stream;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":149,"./lib/_stream_passthrough.js":150,"./lib/_stream_readable.js":151,"./lib/_stream_transform.js":152,"./lib/_stream_writable.js":153,"stream":159}],157:[function(require,module,exports){
+module.exports = require("./lib/_stream_transform.js")
+
+},{"./lib/_stream_transform.js":152}],158:[function(require,module,exports){
+module.exports = require("./lib/_stream_writable.js")
+
+},{"./lib/_stream_writable.js":153}],159:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('readable-stream/readable.js');
+Stream.Writable = require('readable-stream/writable.js');
+Stream.Duplex = require('readable-stream/duplex.js');
+Stream.Transform = require('readable-stream/transform.js');
+Stream.PassThrough = require('readable-stream/passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+
+
+// old-style streams.  Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+  EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+  var source = this;
+
+  function ondata(chunk) {
+    if (dest.writable) {
+      if (false === dest.write(chunk) && source.pause) {
+        source.pause();
+      }
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  var didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    if (EE.listenerCount(this, 'error') === 0) {
+      throw er; // Unhandled stream error in pipe.
+    }
+  }
+
+  source.on('error', onerror);
+  dest.on('error', onerror);
+
+  // remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
+
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
+
+    dest.removeListener('close', cleanup);
+  }
+
+  source.on('end', cleanup);
+  source.on('close', cleanup);
+
+  dest.on('close', cleanup);
+
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
+};
+
+},{"events":143,"inherits":144,"readable-stream/duplex.js":148,"readable-stream/passthrough.js":155,"readable-stream/readable.js":156,"readable-stream/transform.js":157,"readable-stream/writable.js":158}],160:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+  || function(encoding) {
+       switch (encoding && encoding.toLowerCase()) {
+         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+         default: return false;
+       }
+     }
+
+
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
+  }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.StringDecoder = function(encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
+  switch (this.encoding) {
+    case 'utf8':
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
+      break;
+    case 'base64':
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
+      break;
+    default:
+      this.write = passThroughWrite;
+      return;
+  }
+
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = (buffer.length >= this.charLength - this.charReceived) ?
+        this.charLength - this.charReceived :
+        buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
+
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
+  }
+
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
+
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
+  }
+
+  charStr += buffer.toString(this.encoding, 0, end);
+
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
+  }
+
+  // or just emit the charStr
+  return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
+    }
+
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
+  }
+  this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+  var res = '';
+  if (buffer && buffer.length)
+    res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
+  }
+
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
+}
+
+},{"buffer":139}],161:[function(require,module,exports){
+exports.isatty = function () { return false; };
+
+function ReadStream() {
+  throw new Error('tty.ReadStream is not implemented');
+}
+exports.ReadStream = ReadStream;
+
+function WriteStream() {
+  throw new Error('tty.ReadStream is not implemented');
+}
+exports.WriteStream = WriteStream;
+
+},{}],162:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}
+},{}],163:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j':
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return '[Circular]';
+        }
+      default:
+        return x;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += ' ' + x;
+    } else {
+      str += ' ' + inspect(x);
+    }
+  }
+  return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+  // Allow for deprecating things in the process of starting up.
+  if (isUndefined(global.process)) {
+    return function() {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+  if (isUndefined(debugEnviron))
+    debugEnviron = process.env.NODE_DEBUG || '';
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+      var pid = process.pid;
+      debugs[set] = function() {
+        var msg = exports.format.apply(exports, arguments);
+        console.error('%s %d: %s', set, pid, msg);
+      };
+    } else {
+      debugs[set] = function() {};
+    }
+  }
+  return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    exports._extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold' : [1, 22],
+  'italic' : [3, 23],
+  'underline' : [4, 24],
+  'inverse' : [7, 27],
+  'white' : [37, 39],
+  'grey' : [90, 39],
+  'black' : [30, 39],
+  'blue' : [34, 39],
+  'cyan' : [36, 39],
+  'green' : [32, 39],
+  'magenta' : [35, 39],
+  'red' : [31, 39],
+  'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+           '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function(val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect &&
+      value &&
+      isFunction(value.inspect) &&
+      // Filter out the util module, it's inspect function is special
+      value.inspect !== exports.inspect &&
+      // Also filter out any prototype objects using the circular check.
+      !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value)
+      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+
+  var base = '', array = false, braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                             .replace(/'/g, "\\'")
+                                             .replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value))
+    return ctx.stylize('' + value, 'number');
+  if (isBoolean(value))
+    return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value))
+    return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+  return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function(key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+          key, true));
+    }
+  });
+  return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function(line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function(line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'")
+                 .replace(/\\"/g, '"')
+                 .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function(prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] +
+           (base === '' ? '' : base + '\n ') +
+           ' ' +
+           output.join(',\n  ') +
+           ' ' +
+           braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return isObject(e) &&
+      (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":162,"_process":147,"inherits":144}],164:[function(require,module,exports){
+(function (process){
+'use strict';
+var escapeStringRegexp = require('escape-string-regexp');
+var ansiStyles = require('ansi-styles');
+var stripAnsi = require('strip-ansi');
+var hasAnsi = require('has-ansi');
+var supportsColor = require('supports-color');
+var defineProps = Object.defineProperties;
+
+function Chalk(options) {
+	// detect mode if not set manually
+	this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled;
+}
+
+// use bright blue on Windows as the normal blue color is illegible
+if (process.platform === 'win32') {
+	ansiStyles.blue.open = '\u001b[94m';
+}
+
+function build(_styles) {
+	var builder = function builder() {
+		return applyStyle.apply(builder, arguments);
+	};
+	builder._styles = _styles;
+	builder.enabled = this.enabled;
+	// __proto__ is used because we must return a function, but there is
+	// no way to create a function with a different prototype.
+	builder.__proto__ = proto;
+	return builder;
+}
+
+var styles = (function () {
+	var ret = {};
+
+	Object.keys(ansiStyles).forEach(function (key) {
+		ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+
+		ret[key] = {
+			get: function () {
+				return build.call(this, this._styles.concat(key));
+			}
+		};
+	});
+
+	return ret;
+})();
+
+var proto = defineProps(function chalk() {}, styles);
+
+function applyStyle() {
+	// support varags, but simply cast to string in case there's only one arg
+	var args = arguments;
+	var argsLen = args.length;
+	var str = argsLen !== 0 && String(arguments[0]);
+	if (argsLen > 1) {
+		// don't slice `arguments`, it prevents v8 optimizations
+		for (var a = 1; a < argsLen; a++) {
+			str += ' ' + args[a];
+		}
+	}
+
+	if (!this.enabled || !str) {
+		return str;
+	}
+
+	/*jshint validthis: true */
+	var nestedStyles = this._styles;
+
+	var i = nestedStyles.length;
+	while (i--) {
+		var code = ansiStyles[nestedStyles[i]];
+		// Replace any instances already present with a re-opening code
+		// otherwise only the part of the string until said closing code
+		// will be colored, and the rest will simply be 'plain'.
+		str = code.open + str.replace(code.closeRe, code.open) + code.close;
+	}
+
+	return str;
+}
+
+function init() {
+	var ret = {};
+
+	Object.keys(styles).forEach(function (name) {
+		ret[name] = {
+			get: function () {
+				return build.call(this, [name]);
+			}
+		};
+	});
+
+	return ret;
+}
+
+defineProps(Chalk.prototype, init());
+
+module.exports = new Chalk();
+module.exports.styles = ansiStyles;
+module.exports.hasColor = hasAnsi;
+module.exports.stripColor = stripAnsi;
+module.exports.supportsColor = supportsColor;
+
+}).call(this,require('_process'))
+},{"_process":147,"ansi-styles":165,"escape-string-regexp":166,"has-ansi":167,"strip-ansi":169,"supports-color":171}],165:[function(require,module,exports){
+'use strict';
+
+var styles = module.exports = {
+	modifiers: {
+		reset: [0, 0],
+		bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	colors: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		gray: [90, 39]
+	},
+	bgColors: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49]
+	}
+};
+
+// fix humans
+styles.colors.grey = styles.colors.gray;
+
+Object.keys(styles).forEach(function (groupName) {
+	var group = styles[groupName];
+
+	Object.keys(group).forEach(function (styleName) {
+		var style = group[styleName];
+
+		styles[styleName] = group[styleName] = {
+			open: '\u001b[' + style[0] + 'm',
+			close: '\u001b[' + style[1] + 'm'
+		};
+	});
+
+	Object.defineProperty(styles, groupName, {
+		value: group,
+		enumerable: false
+	});
+});
+
+},{}],166:[function(require,module,exports){
+'use strict';
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+
+module.exports = function (str) {
+	if (typeof str !== 'string') {
+		throw new TypeError('Expected a string');
+	}
+
+	return str.replace(matchOperatorsRe,  '\\$&');
+};
+
+},{}],167:[function(require,module,exports){
+'use strict';
+var ansiRegex = require('ansi-regex');
+var re = new RegExp(ansiRegex().source); // remove the `g` flag
+module.exports = re.test.bind(re);
+
+},{"ansi-regex":168}],168:[function(require,module,exports){
+'use strict';
+module.exports = function () {
+	return /(?:(?:\u001b\[)|\u009b)(?:(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m])|\u001b[A-M]/g;
+};
+
+},{}],169:[function(require,module,exports){
+'use strict';
+var ansiRegex = require('ansi-regex')();
+
+module.exports = function (str) {
+	return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
+};
+
+},{"ansi-regex":170}],170:[function(require,module,exports){
+arguments[4][168][0].apply(exports,arguments)
+},{"dup":168}],171:[function(require,module,exports){
+(function (process){
+'use strict';
+var argv = process.argv;
+
+module.exports = (function () {
+	if ('FORCE_COLOR' in process.env) {
+		return true;
+	}
+
+	if (argv.indexOf('--no-color') !== -1 ||
+		argv.indexOf('--no-colors') !== -1 ||
+		argv.indexOf('--color=false') !== -1) {
+		return false;
+	}
+
+	if (argv.indexOf('--color') !== -1 ||
+		argv.indexOf('--colors') !== -1 ||
+		argv.indexOf('--color=true') !== -1 ||
+		argv.indexOf('--color=always') !== -1) {
+		return true;
+	}
+
+	if (process.stdout && !process.stdout.isTTY) {
+		return false;
+	}
+
+	if ('UPSTART_JOB' in process.env) {
+		return false;
+	}
+
+	if (process.platform === 'win32') {
+		return true;
+	}
+
+	if ('COLORTERM' in process.env) {
+		return true;
+	}
+
+	if (process.env.TERM === 'dumb') {
+		return false;
+	}
+
+	if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(process.env.TERM)) {
+		return true;
+	}
+
+	return false;
+})();
+
+}).call(this,require('_process'))
+},{"_process":147}],172:[function(require,module,exports){
+/**
+ * Core.js 0.6.1
+ * https://github.com/zloirock/core-js
+ * License: http://rock.mit-license.org
+ * © 2015 Denis Pushkarev
+ */
+!function(global, framework, undefined){
+'use strict';
+
+/******************************************************************************
+ * Module : common                                                            *
+ ******************************************************************************/
+
+  // Shortcuts for [[Class]] & property names
+var OBJECT          = 'Object'
+  , FUNCTION        = 'Function'
+  , ARRAY           = 'Array'
+  , STRING          = 'String'
+  , NUMBER          = 'Number'
+  , REGEXP          = 'RegExp'
+  , DATE            = 'Date'
+  , MAP             = 'Map'
+  , SET             = 'Set'
+  , WEAKMAP         = 'WeakMap'
+  , WEAKSET         = 'WeakSet'
+  , SYMBOL          = 'Symbol'
+  , PROMISE         = 'Promise'
+  , MATH            = 'Math'
+  , ARGUMENTS       = 'Arguments'
+  , PROTOTYPE       = 'prototype'
+  , CONSTRUCTOR     = 'constructor'
+  , TO_STRING       = 'toString'
+  , TO_STRING_TAG   = TO_STRING + 'Tag'
+  , TO_LOCALE       = 'toLocaleString'
+  , HAS_OWN         = 'hasOwnProperty'
+  , FOR_EACH        = 'forEach'
+  , ITERATOR        = 'iterator'
+  , FF_ITERATOR     = '@@' + ITERATOR
+  , PROCESS         = 'process'
+  , CREATE_ELEMENT  = 'createElement'
+  // Aliases global objects and prototypes
+  , Function        = global[FUNCTION]
+  , Object          = global[OBJECT]
+  , Array           = global[ARRAY]
+  , String          = global[STRING]
+  , Number          = global[NUMBER]
+  , RegExp          = global[REGEXP]
+  , Date            = global[DATE]
+  , Map             = global[MAP]
+  , Set             = global[SET]
+  , WeakMap         = global[WEAKMAP]
+  , WeakSet         = global[WEAKSET]
+  , Symbol          = global[SYMBOL]
+  , Math            = global[MATH]
+  , TypeError       = global.TypeError
+  , RangeError      = global.RangeError
+  , setTimeout      = global.setTimeout
+  , setImmediate    = global.setImmediate
+  , clearImmediate  = global.clearImmediate
+  , parseInt        = global.parseInt
+  , isFinite        = global.isFinite
+  , process         = global[PROCESS]
+  , nextTick        = process && process.nextTick
+  , document        = global.document
+  , html            = document && document.documentElement
+  , navigator       = global.navigator
+  , define          = global.define
+  , console         = global.console || {}
+  , ArrayProto      = Array[PROTOTYPE]
+  , ObjectProto     = Object[PROTOTYPE]
+  , FunctionProto   = Function[PROTOTYPE]
+  , Infinity        = 1 / 0
+  , DOT             = '.';
+
+// http://jsperf.com/core-js-isobject
+function isObject(it){
+  return it !== null && (typeof it == 'object' || typeof it == 'function');
+}
+function isFunction(it){
+  return typeof it == 'function';
+}
+// Native function?
+var isNative = ctx(/./.test, /\[native code\]\s*\}\s*$/, 1);
+
+// Object internal [[Class]] or toStringTag
+// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring
+var toString = ObjectProto[TO_STRING];
+function setToStringTag(it, tag, stat){
+  if(it && !has(it = stat ? it : it[PROTOTYPE], SYMBOL_TAG))hidden(it, SYMBOL_TAG, tag);
+}
+function cof(it){
+  return toString.call(it).slice(8, -1);
+}
+function classof(it){
+  var O, T;
+  return it == undefined ? it === undefined ? 'Undefined' : 'Null'
+    : typeof (T = (O = Object(it))[SYMBOL_TAG]) == 'string' ? T : cof(O);
+}
+
+// Function
+var call  = FunctionProto.call
+  , apply = FunctionProto.apply
+  , REFERENCE_GET;
+// Partial apply
+function part(/* ...args */){
+  var fn     = assertFunction(this)
+    , length = arguments.length
+    , args   = Array(length)
+    , i      = 0
+    , _      = path._
+    , holder = false;
+  while(length > i)if((args[i] = arguments[i++]) === _)holder = true;
+  return function(/* ...args */){
+    var that    = this
+      , _length = arguments.length
+      , i = 0, j = 0, _args;
+    if(!holder && !_length)return invoke(fn, args, that);
+    _args = args.slice();
+    if(holder)for(;length > i; i++)if(_args[i] === _)_args[i] = arguments[j++];
+    while(_length > j)_args.push(arguments[j++]);
+    return invoke(fn, _args, that);
+  }
+}
+// Optional / simple context binding
+function ctx(fn, that, length){
+  assertFunction(fn);
+  if(~length && that === undefined)return fn;
+  switch(length){
+    case 1: return function(a){
+      return fn.call(that, a);
+    }
+    case 2: return function(a, b){
+      return fn.call(that, a, b);
+    }
+    case 3: return function(a, b, c){
+      return fn.call(that, a, b, c);
+    }
+  } return function(/* ...args */){
+      return fn.apply(that, arguments);
+  }
+}
+// Fast apply
+// http://jsperf.lnkit.com/fast-apply/5
+function invoke(fn, args, that){
+  var un = that === undefined;
+  switch(args.length | 0){
+    case 0: return un ? fn()
+                      : fn.call(that);
+    case 1: return un ? fn(args[0])
+                      : fn.call(that, args[0]);
+    case 2: return un ? fn(args[0], args[1])
+                      : fn.call(that, args[0], args[1]);
+    case 3: return un ? fn(args[0], args[1], args[2])
+                      : fn.call(that, args[0], args[1], args[2]);
+    case 4: return un ? fn(args[0], args[1], args[2], args[3])
+                      : fn.call(that, args[0], args[1], args[2], args[3]);
+    case 5: return un ? fn(args[0], args[1], args[2], args[3], args[4])
+                      : fn.call(that, args[0], args[1], args[2], args[3], args[4]);
+  } return              fn.apply(that, args);
+}
+
+// Object:
+var create           = Object.create
+  , getPrototypeOf   = Object.getPrototypeOf
+  , setPrototypeOf   = Object.setPrototypeOf
+  , defineProperty   = Object.defineProperty
+  , defineProperties = Object.defineProperties
+  , getOwnDescriptor = Object.getOwnPropertyDescriptor
+  , getKeys          = Object.keys
+  , getNames         = Object.getOwnPropertyNames
+  , getSymbols       = Object.getOwnPropertySymbols
+  , isFrozen         = Object.isFrozen
+  , has              = ctx(call, ObjectProto[HAS_OWN], 2)
+  // Dummy, fix for not array-like ES3 string in es5 module
+  , ES5Object        = Object
+  , Dict;
+function toObject(it){
+  return ES5Object(assertDefined(it));
+}
+function returnIt(it){
+  return it;
+}
+function returnThis(){
+  return this;
+}
+function get(object, key){
+  if(has(object, key))return object[key];
+}
+function ownKeys(it){
+  assertObject(it);
+  return getSymbols ? getNames(it).concat(getSymbols(it)) : getNames(it);
+}
+// 19.1.2.1 Object.assign(target, source, ...)
+var assign = Object.assign || function(target, source){
+  var T = Object(assertDefined(target))
+    , l = arguments.length
+    , i = 1;
+  while(l > i){
+    var S      = ES5Object(arguments[i++])
+      , keys   = getKeys(S)
+      , length = keys.length
+      , j      = 0
+      , key;
+    while(length > j)T[key = keys[j++]] = S[key];
+  }
+  return T;
+}
+function keyOf(object, el){
+  var O      = toObject(object)
+    , keys   = getKeys(O)
+    , length = keys.length
+    , index  = 0
+    , key;
+  while(length > index)if(O[key = keys[index++]] === el)return key;
+}
+
+// Array
+// array('str1,str2,str3') => ['str1', 'str2', 'str3']
+function array(it){
+  return String(it).split(',');
+}
+var push    = ArrayProto.push
+  , unshift = ArrayProto.unshift
+  , slice   = ArrayProto.slice
+  , splice  = ArrayProto.splice
+  , indexOf = ArrayProto.indexOf
+  , forEach = ArrayProto[FOR_EACH];
+/*
+ * 0 -> forEach
+ * 1 -> map
+ * 2 -> filter
+ * 3 -> some
+ * 4 -> every
+ * 5 -> find
+ * 6 -> findIndex
+ */
+function createArrayMethod(type){
+  var isMap       = type == 1
+    , isFilter    = type == 2
+    , isSome      = type == 3
+    , isEvery     = type == 4
+    , isFindIndex = type == 6
+    , noholes     = type == 5 || isFindIndex;
+  return function(callbackfn/*, that = undefined */){
+    var O      = Object(assertDefined(this))
+      , that   = arguments[1]
+      , self   = ES5Object(O)
+      , f      = ctx(callbackfn, that, 3)
+      , length = toLength(self.length)
+      , index  = 0
+      , result = isMap ? Array(length) : isFilter ? [] : undefined
+      , val, res;
+    for(;length > index; index++)if(noholes || index in self){
+      val = self[index];
+      res = f(val, index, O);
+      if(type){
+        if(isMap)result[index] = res;             // map
+        else if(res)switch(type){
+          case 3: return true;                    // some
+          case 5: return val;                     // find
+          case 6: return index;                   // findIndex
+          case 2: result.push(val);               // filter
+        } else if(isEvery)return false;           // every
+      }
+    }
+    return isFindIndex ? -1 : isSome || isEvery ? isEvery : result;
+  }
+}
+function createArrayContains(isContains){
+  return function(el /*, fromIndex = 0 */){
+    var O      = toObject(this)
+      , length = toLength(O.length)
+      , index  = toIndex(arguments[1], length);
+    if(isContains && el != el){
+      for(;length > index; index++)if(sameNaN(O[index]))return isContains || index;
+    } else for(;length > index; index++)if(isContains || index in O){
+      if(O[index] === el)return isContains || index;
+    } return !isContains && -1;
+  }
+}
+function generic(A, B){
+  // strange IE quirks mode bug -> use typeof vs isFunction
+  return typeof A == 'function' ? A : B;
+}
+
+// Math
+var MAX_SAFE_INTEGER = 0x1fffffffffffff // pow(2, 53) - 1 == 9007199254740991
+  , pow    = Math.pow
+  , abs    = Math.abs
+  , ceil   = Math.ceil
+  , floor  = Math.floor
+  , max    = Math.max
+  , min    = Math.min
+  , random = Math.random
+  , trunc  = Math.trunc || function(it){
+      return (it > 0 ? floor : ceil)(it);
+    }
+// 20.1.2.4 Number.isNaN(number)
+function sameNaN(number){
+  return number != number;
+}
+// 7.1.4 ToInteger
+function toInteger(it){
+  return isNaN(it) ? 0 : trunc(it);
+}
+// 7.1.15 ToLength
+function toLength(it){
+  return it > 0 ? min(toInteger(it), MAX_SAFE_INTEGER) : 0;
+}
+function toIndex(index, length){
+  var index = toInteger(index);
+  return index < 0 ? max(index + length, 0) : min(index, length);
+}
+function lz(num){
+  return num > 9 ? num : '0' + num;
+}
+
+function createReplacer(regExp, replace, isStatic){
+  var replacer = isObject(replace) ? function(part){
+    return replace[part];
+  } : replace;
+  return function(it){
+    return String(isStatic ? it : this).replace(regExp, replacer);
+  }
+}
+function createPointAt(toString){
+  return function(pos){
+    var s = String(assertDefined(this))
+      , i = toInteger(pos)
+      , l = s.length
+      , a, b;
+    if(i < 0 || i >= l)return toString ? '' : undefined;
+    a = s.charCodeAt(i);
+    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+      ? toString ? s.charAt(i) : a
+      : toString ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+  }
+}
+
+// Assertion & errors
+var REDUCE_ERROR = 'Reduce of empty object with no initial value';
+function assert(condition, msg1, msg2){
+  if(!condition)throw TypeError(msg2 ? msg1 + msg2 : msg1);
+}
+function assertDefined(it){
+  if(it == undefined)throw TypeError('Function called on null or undefined');
+  return it;
+}
+function assertFunction(it){
+  assert(isFunction(it), it, ' is not a function!');
+  return it;
+}
+function assertObject(it){
+  assert(isObject(it), it, ' is not an object!');
+  return it;
+}
+function assertInstance(it, Constructor, name){
+  assert(it instanceof Constructor, name, ": use the 'new' operator!");
+}
+
+// Property descriptors & Symbol
+function descriptor(bitmap, value){
+  return {
+    enumerable  : !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable    : !(bitmap & 4),
+    value       : value
+  }
+}
+function simpleSet(object, key, value){
+  object[key] = value;
+  return object;
+}
+function createDefiner(bitmap){
+  return DESC ? function(object, key, value){
+    return defineProperty(object, key, descriptor(bitmap, value));
+  } : simpleSet;
+}
+function uid(key){
+  return SYMBOL + '(' + key + ')_' + (++sid + random())[TO_STRING](36);
+}
+function getWellKnownSymbol(name, setter){
+  return (Symbol && Symbol[name]) || (setter ? Symbol : safeSymbol)(SYMBOL + DOT + name);
+}
+// The engine works fine with descriptors? Thank's IE8 for his funny defineProperty.
+var DESC = !!function(){
+      try {
+        return defineProperty({}, 'a', {get: function(){ return 2 }}).a == 2;
+      } catch(e){}
+    }()
+  , sid    = 0
+  , hidden = createDefiner(1)
+  , set    = Symbol ? simpleSet : hidden
+  , safeSymbol = Symbol || uid;
+function assignHidden(target, src){
+  for(var key in src)hidden(target, key, src[key]);
+  return target;
+}
+
+var SYMBOL_UNSCOPABLES = getWellKnownSymbol('unscopables')
+  , ArrayUnscopables   = ArrayProto[SYMBOL_UNSCOPABLES] || {}
+  , SYMBOL_TAG         = getWellKnownSymbol(TO_STRING_TAG)
+  , SYMBOL_SPECIES     = getWellKnownSymbol('species')
+  , SYMBOL_ITERATOR;
+function setSpecies(C){
+  if(DESC && (framework || !isNative(C)))defineProperty(C, SYMBOL_SPECIES, {
+    configurable: true,
+    get: returnThis
+  });
+}
+
+/******************************************************************************
+ * Module : common.export                                                     *
+ ******************************************************************************/
+
+var NODE = cof(process) == PROCESS
+  , core = {}
+  , path = framework ? global : core
+  , old  = global.core
+  , exportGlobal
+  // type bitmap
+  , FORCED = 1
+  , GLOBAL = 2
+  , STATIC = 4
+  , PROTO  = 8
+  , BIND   = 16
+  , WRAP   = 32;
+function $define(type, name, source){
+  var key, own, out, exp
+    , isGlobal = type & GLOBAL
+    , target   = isGlobal ? global : (type & STATIC)
+        ? global[name] : (global[name] || ObjectProto)[PROTOTYPE]
+    , exports  = isGlobal ? core : core[name] || (core[name] = {});
+  if(isGlobal)source = name;
+  for(key in source){
+    // there is a similar native
+    own = !(type & FORCED) && target && key in target
+      && (!isFunction(target[key]) || isNative(target[key]));
+    // export native or passed
+    out = (own ? target : source)[key];
+    // prevent global pollution for namespaces
+    if(!framework && isGlobal && !isFunction(target[key]))exp = source[key];
+    // bind timers to global for call from export context
+    else if(type & BIND && own)exp = ctx(out, global);
+    // wrap global constructors for prevent change them in library
+    else if(type & WRAP && !framework && target[key] == out){
+      exp = function(param){
+        return this instanceof out ? new out(param) : out(param);
+      }
+      exp[PROTOTYPE] = out[PROTOTYPE];
+    } else exp = type & PROTO && isFunction(out) ? ctx(call, out) : out;
+    // extend global
+    if(framework && target && !own){
+      if(isGlobal)target[key] = out;
+      else delete target[key] && hidden(target, key, out);
+    }
+    // export
+    if(exports[key] != out)hidden(exports, key, exp);
+  }
+}
+// CommonJS export
+if(typeof module != 'undefined' && module.exports)module.exports = core;
+// RequireJS export
+else if(isFunction(define) && define.amd)define(function(){return core});
+// Export to global object
+else exportGlobal = true;
+if(exportGlobal || framework){
+  core.noConflict = function(){
+    global.core = old;
+    return core;
+  }
+  global.core = core;
+}
+
+/******************************************************************************
+ * Module : common.iterators                                                  *
+ ******************************************************************************/
+
+SYMBOL_ITERATOR = getWellKnownSymbol(ITERATOR);
+var ITER  = safeSymbol('iter')
+  , KEY   = 1
+  , VALUE = 2
+  , Iterators = {}
+  , IteratorPrototype = {}
+    // Safari has byggy iterators w/o `next`
+  , BUGGY_ITERATORS = 'keys' in ArrayProto && !('next' in [].keys());
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+setIterator(IteratorPrototype, returnThis);
+function setIterator(O, value){
+  hidden(O, SYMBOL_ITERATOR, value);
+  // Add iterator for FF iterator protocol
+  FF_ITERATOR in ArrayProto && hidden(O, FF_ITERATOR, value);
+}
+function createIterator(Constructor, NAME, next, proto){
+  Constructor[PROTOTYPE] = create(proto || IteratorPrototype, {next: descriptor(1, next)});
+  setToStringTag(Constructor, NAME + ' Iterator');
+}
+function defineIterator(Constructor, NAME, value, DEFAULT){
+  var proto = Constructor[PROTOTYPE]
+    , iter  = get(proto, SYMBOL_ITERATOR) || get(proto, FF_ITERATOR) || (DEFAULT && get(proto, DEFAULT)) || value;
+  if(framework){
+    // Define iterator
+    setIterator(proto, iter);
+    if(iter !== value){
+      var iterProto = getPrototypeOf(iter.call(new Constructor));
+      // Set @@toStringTag to native iterators
+      setToStringTag(iterProto, NAME + ' Iterator', true);
+      // FF fix
+      has(proto, FF_ITERATOR) && setIterator(iterProto, returnThis);
+    }
+  }
+  // Plug for library
+  Iterators[NAME] = iter;
+  // FF & v8 fix
+  Iterators[NAME + ' Iterator'] = returnThis;
+  return iter;
+}
+function defineStdIterators(Base, NAME, Constructor, next, DEFAULT, IS_SET){
+  function createIter(kind){
+    return function(){
+      return new Constructor(this, kind);
+    }
+  }
+  createIterator(Constructor, NAME, next);
+  var entries = createIter(KEY+VALUE)
+    , values  = createIter(VALUE);
+  if(DEFAULT == VALUE)values = defineIterator(Base, NAME, values, 'values');
+  else entries = defineIterator(Base, NAME, entries, 'entries');
+  if(DEFAULT){
+    $define(PROTO + FORCED * BUGGY_ITERATORS, NAME, {
+      entries: entries,
+      keys: IS_SET ? values : createIter(KEY),
+      values: values
+    });
+  }
+}
+function iterResult(done, value){
+  return {value: value, done: !!done};
+}
+function isIterable(it){
+  var O      = Object(it)
+    , Symbol = global[SYMBOL]
+    , hasExt = (Symbol && Symbol[ITERATOR] || FF_ITERATOR) in O;
+  return hasExt || SYMBOL_ITERATOR in O || has(Iterators, classof(O));
+}
+function getIterator(it){
+  var Symbol  = global[SYMBOL]
+    , ext     = it[Symbol && Symbol[ITERATOR] || FF_ITERATOR]
+    , getIter = ext || it[SYMBOL_ITERATOR] || Iterators[classof(it)];
+  return assertObject(getIter.call(it));
+}
+function stepCall(fn, value, entries){
+  return entries ? invoke(fn, value) : fn(value);
+}
+function checkDangerIterClosing(fn){
+  var danger = true;
+  var O = {
+    next: function(){ throw 1 },
+    'return': function(){ danger = false }
+  };
+  O[SYMBOL_ITERATOR] = returnThis;
+  try {
+    fn(O);
+  } catch(e){}
+  return danger;
+}
+function closeIterator(iterator){
+  var ret = iterator['return'];
+  if(ret !== undefined)ret.call(iterator);
+}
+function safeIterClose(exec, iterator){
+  try {
+    exec(iterator);
+  } catch(e){
+    closeIterator(iterator);
+    throw e;
+  }
+}
+function forOf(iterable, entries, fn, that){
+  safeIterClose(function(iterator){
+    var f = ctx(fn, that, entries ? 2 : 1)
+      , step;
+    while(!(step = iterator.next()).done)if(stepCall(f, step.value, entries) === false){
+      return closeIterator(iterator);
+    }
+  }, getIterator(iterable));
+}
+
+/******************************************************************************
+ * Module : es6.symbol                                                        *
+ ******************************************************************************/
+
+// ECMAScript 6 symbols shim
+!function(TAG, SymbolRegistry, AllSymbols, setter){
+  // 19.4.1.1 Symbol([description])
+  if(!isNative(Symbol)){
+    Symbol = function(description){
+      assert(!(this instanceof Symbol), SYMBOL + ' is not a ' + CONSTRUCTOR);
+      var tag = uid(description)
+        , sym = set(create(Symbol[PROTOTYPE]), TAG, tag);
+      AllSymbols[tag] = sym;
+      DESC && setter && defineProperty(ObjectProto, tag, {
+        configurable: true,
+        set: function(value){
+          hidden(this, tag, value);
+        }
+      });
+      return sym;
+    }
+    hidden(Symbol[PROTOTYPE], TO_STRING, function(){
+      return this[TAG];
+    });
+  }
+  $define(GLOBAL + WRAP, {Symbol: Symbol});
+  
+  var symbolStatics = {
+    // 19.4.2.1 Symbol.for(key)
+    'for': function(key){
+      return has(SymbolRegistry, key += '')
+        ? SymbolRegistry[key]
+        : SymbolRegistry[key] = Symbol(key);
+    },
+    // 19.4.2.4 Symbol.iterator
+    iterator: SYMBOL_ITERATOR || getWellKnownSymbol(ITERATOR),
+    // 19.4.2.5 Symbol.keyFor(sym)
+    keyFor: part.call(keyOf, SymbolRegistry),
+    // 19.4.2.10 Symbol.species
+    species: SYMBOL_SPECIES,
+    // 19.4.2.13 Symbol.toStringTag
+    toStringTag: SYMBOL_TAG = getWellKnownSymbol(TO_STRING_TAG, true),
+    // 19.4.2.14 Symbol.unscopables
+    unscopables: SYMBOL_UNSCOPABLES,
+    pure: safeSymbol,
+    set: set,
+    useSetter: function(){setter = true},
+    useSimple: function(){setter = false}
+  };
+  // 19.4.2.2 Symbol.hasInstance
+  // 19.4.2.3 Symbol.isConcatSpreadable
+  // 19.4.2.6 Symbol.match
+  // 19.4.2.8 Symbol.replace
+  // 19.4.2.9 Symbol.search
+  // 19.4.2.11 Symbol.split
+  // 19.4.2.12 Symbol.toPrimitive
+  forEach.call(array('hasInstance,isConcatSpreadable,match,replace,search,split,toPrimitive'),
+    function(it){
+      symbolStatics[it] = getWellKnownSymbol(it);
+    }
+  );
+  $define(STATIC, SYMBOL, symbolStatics);
+  
+  setToStringTag(Symbol, SYMBOL);
+  
+  $define(STATIC + FORCED * !isNative(Symbol), OBJECT, {
+    // 19.1.2.7 Object.getOwnPropertyNames(O)
+    getOwnPropertyNames: function(it){
+      var names = getNames(toObject(it)), result = [], key, i = 0;
+      while(names.length > i)has(AllSymbols, key = names[i++]) || result.push(key);
+      return result;
+    },
+    // 19.1.2.8 Object.getOwnPropertySymbols(O)
+    getOwnPropertySymbols: function(it){
+      var names = getNames(toObject(it)), result = [], key, i = 0;
+      while(names.length > i)has(AllSymbols, key = names[i++]) && result.push(AllSymbols[key]);
+      return result;
+    }
+  });
+  
+  // 20.2.1.9 Math[@@toStringTag]
+  setToStringTag(Math, MATH, true);
+  // 24.3.3 JSON[@@toStringTag]
+  setToStringTag(global.JSON, 'JSON', true);
+}(safeSymbol('tag'), {}, {}, true);
+
+/******************************************************************************
+ * Module : es6.object.statics                                                *
+ ******************************************************************************/
+
+!function(){
+  var objectStatic = {
+    // 19.1.3.1 Object.assign(target, source)
+    assign: assign,
+    // 19.1.3.10 Object.is(value1, value2)
+    is: function(x, y){
+      return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
+    }
+  };
+  // 19.1.3.19 Object.setPrototypeOf(O, proto)
+  // Works with __proto__ only. Old v8 can't works with null proto objects.
+  '__proto__' in ObjectProto && function(buggy, set){
+    try {
+      set = ctx(call, getOwnDescriptor(ObjectProto, '__proto__').set, 2);
+      set({}, ArrayProto);
+    } catch(e){ buggy = true }
+    objectStatic.setPrototypeOf = setPrototypeOf = setPrototypeOf || function(O, proto){
+      assertObject(O);
+      assert(proto === null || isObject(proto), proto, ": can't set as prototype!");
+      if(buggy)O.__proto__ = proto;
+      else set(O, proto);
+      return O;
+    }
+  }();
+  $define(STATIC, OBJECT, objectStatic);
+}();
+
+/******************************************************************************
+ * Module : es6.object.statics-accept-primitives                              *
+ ******************************************************************************/
+
+!function(){
+  // Object static methods accept primitives
+  function wrapObjectMethod(key, MODE){
+    var fn  = Object[key]
+      , exp = core[OBJECT][key]
+      , f   = 0
+      , o   = {};
+    if(!exp || isNative(exp)){
+      o[key] = MODE == 1 ? function(it){
+        return isObject(it) ? fn(it) : it;
+      } : MODE == 2 ? function(it){
+        return isObject(it) ? fn(it) : true;
+      } : MODE == 3 ? function(it){
+        return isObject(it) ? fn(it) : false;
+      } : MODE == 4 ? function(it, key){
+        return fn(toObject(it), key);
+      } : function(it){
+        return fn(toObject(it));
+      };
+      try { fn(DOT) }
+      catch(e){ f = 1 }
+      $define(STATIC + FORCED * f, OBJECT, o);
+    }
+  }
+  wrapObjectMethod('freeze', 1);
+  wrapObjectMethod('seal', 1);
+  wrapObjectMethod('preventExtensions', 1);
+  wrapObjectMethod('isFrozen', 2);
+  wrapObjectMethod('isSealed', 2);
+  wrapObjectMethod('isExtensible', 3);
+  wrapObjectMethod('getOwnPropertyDescriptor', 4);
+  wrapObjectMethod('getPrototypeOf');
+  wrapObjectMethod('keys');
+  wrapObjectMethod('getOwnPropertyNames');
+}();
+
+/******************************************************************************
+ * Module : es6.number.statics                                                *
+ ******************************************************************************/
+
+!function(isInteger){
+  $define(STATIC, NUMBER, {
+    // 20.1.2.1 Number.EPSILON
+    EPSILON: pow(2, -52),
+    // 20.1.2.2 Number.isFinite(number)
+    isFinite: function(it){
+      return typeof it == 'number' && isFinite(it);
+    },
+    // 20.1.2.3 Number.isInteger(number)
+    isInteger: isInteger,
+    // 20.1.2.4 Number.isNaN(number)
+    isNaN: sameNaN,
+    // 20.1.2.5 Number.isSafeInteger(number)
+    isSafeInteger: function(number){
+      return isInteger(number) && abs(number) <= MAX_SAFE_INTEGER;
+    },
+    // 20.1.2.6 Number.MAX_SAFE_INTEGER
+    MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
+    // 20.1.2.10 Number.MIN_SAFE_INTEGER
+    MIN_SAFE_INTEGER: -MAX_SAFE_INTEGER,
+    // 20.1.2.12 Number.parseFloat(string)
+    parseFloat: parseFloat,
+    // 20.1.2.13 Number.parseInt(string, radix)
+    parseInt: parseInt
+  });
+// 20.1.2.3 Number.isInteger(number)
+}(Number.isInteger || function(it){
+  return !isObject(it) && isFinite(it) && floor(it) === it;
+});
+
+/******************************************************************************
+ * Module : es6.math                                                          *
+ ******************************************************************************/
+
+// ECMAScript 6 shim
+!function(){
+  // 20.2.2.28 Math.sign(x)
+  var E    = Math.E
+    , exp  = Math.exp
+    , log  = Math.log
+    , sqrt = Math.sqrt
+    , sign = Math.sign || function(x){
+        return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
+      };
+  
+  // 20.2.2.5 Math.asinh(x)
+  function asinh(x){
+    return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log(x + sqrt(x * x + 1));
+  }
+  // 20.2.2.14 Math.expm1(x)
+  function expm1(x){
+    return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : exp(x) - 1;
+  }
+    
+  $define(STATIC, MATH, {
+    // 20.2.2.3 Math.acosh(x)
+    acosh: function(x){
+      return (x = +x) < 1 ? NaN : isFinite(x) ? log(x / E + sqrt(x + 1) * sqrt(x - 1) / E) + 1 : x;
+    },
+    // 20.2.2.5 Math.asinh(x)
+    asinh: asinh,
+    // 20.2.2.7 Math.atanh(x)
+    atanh: function(x){
+      return (x = +x) == 0 ? x : log((1 + x) / (1 - x)) / 2;
+    },
+    // 20.2.2.9 Math.cbrt(x)
+    cbrt: function(x){
+      return sign(x = +x) * pow(abs(x), 1 / 3);
+    },
+    // 20.2.2.11 Math.clz32(x)
+    clz32: function(x){
+      return (x >>>= 0) ? 32 - x[TO_STRING](2).length : 32;
+    },
+    // 20.2.2.12 Math.cosh(x)
+    cosh: function(x){
+      return (exp(x = +x) + exp(-x)) / 2;
+    },
+    // 20.2.2.14 Math.expm1(x)
+    expm1: expm1,
+    // 20.2.2.16 Math.fround(x)
+    // TODO: fallback for IE9-
+    fround: function(x){
+      return new Float32Array([x])[0];
+    },
+    // 20.2.2.17 Math.hypot([value1[, value2[, … ]]])
+    hypot: function(value1, value2){
+      var sum  = 0
+        , len1 = arguments.length
+        , len2 = len1
+        , args = Array(len1)
+        , larg = -Infinity
+        , arg;
+      while(len1--){
+        arg = args[len1] = +arguments[len1];
+        if(arg == Infinity || arg == -Infinity)return Infinity;
+        if(arg > larg)larg = arg;
+      }
+      larg = arg || 1;
+      while(len2--)sum += pow(args[len2] / larg, 2);
+      return larg * sqrt(sum);
+    },
+    // 20.2.2.18 Math.imul(x, y)
+    imul: function(x, y){
+      var UInt16 = 0xffff
+        , xn = +x
+        , yn = +y
+        , xl = UInt16 & xn
+        , yl = UInt16 & yn;
+      return 0 | xl * yl + ((UInt16 & xn >>> 16) * yl + xl * (UInt16 & yn >>> 16) << 16 >>> 0);
+    },
+    // 20.2.2.20 Math.log1p(x)
+    log1p: function(x){
+      return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : log(1 + x);
+    },
+    // 20.2.2.21 Math.log10(x)
+    log10: function(x){
+      return log(x) / Math.LN10;
+    },
+    // 20.2.2.22 Math.log2(x)
+    log2: function(x){
+      return log(x) / Math.LN2;
+    },
+    // 20.2.2.28 Math.sign(x)
+    sign: sign,
+    // 20.2.2.30 Math.sinh(x)
+    sinh: function(x){
+      return (abs(x = +x) < 1) ? (expm1(x) - expm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E / 2);
+    },
+    // 20.2.2.33 Math.tanh(x)
+    tanh: function(x){
+      var a = expm1(x = +x)
+        , b = expm1(-x);
+      return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
+    },
+    // 20.2.2.34 Math.trunc(x)
+    trunc: trunc
+  });
+}();
+
+/******************************************************************************
+ * Module : es6.string                                                        *
+ ******************************************************************************/
+
+!function(fromCharCode){
+  function assertNotRegExp(it){
+    if(cof(it) == REGEXP)throw TypeError();
+  }
+  
+  $define(STATIC, STRING, {
+    // 21.1.2.2 String.fromCodePoint(...codePoints)
+    fromCodePoint: function(x){
+      var res = []
+        , len = arguments.length
+        , i   = 0
+        , code
+      while(len > i){
+        code = +arguments[i++];
+        if(toIndex(code, 0x10ffff) !== code)throw RangeError(code + ' is not a valid code point');
+        res.push(code < 0x10000
+          ? fromCharCode(code)
+          : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
+        );
+      } return res.join('');
+    },
+    // 21.1.2.4 String.raw(callSite, ...substitutions)
+    raw: function(callSite){
+      var raw = toObject(callSite.raw)
+        , len = toLength(raw.length)
+        , sln = arguments.length
+        , res = []
+        , i   = 0;
+      while(len > i){
+        res.push(String(raw[i++]));
+        if(i < sln)res.push(String(arguments[i]));
+      } return res.join('');
+    }
+  });
+  
+  $define(PROTO, STRING, {
+    // 21.1.3.3 String.prototype.codePointAt(pos)
+    codePointAt: createPointAt(false),
+    // 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])
+    endsWith: function(searchString /*, endPosition = @length */){
+      assertNotRegExp(searchString);
+      var that = String(assertDefined(this))
+        , endPosition = arguments[1]
+        , len = toLength(that.length)
+        , end = endPosition === undefined ? len : min(toLength(endPosition), len);
+      searchString += '';
+      return that.slice(end - searchString.length, end) === searchString;
+    },
+    // 21.1.3.7 String.prototype.includes(searchString, position = 0)
+    includes: function(searchString /*, position = 0 */){
+      assertNotRegExp(searchString);
+      return !!~String(assertDefined(this)).indexOf(searchString, arguments[1]);
+    },
+    // 21.1.3.13 String.prototype.repeat(count)
+    repeat: function(count){
+      var str = String(assertDefined(this))
+        , res = ''
+        , n   = toInteger(count);
+      if(0 > n || n == Infinity)throw RangeError("Count can't be negative");
+      for(;n > 0; (n >>>= 1) && (str += str))if(n & 1)res += str;
+      return res;
+    },
+    // 21.1.3.18 String.prototype.startsWith(searchString [, position ])
+    startsWith: function(searchString /*, position = 0 */){
+      assertNotRegExp(searchString);
+      var that  = String(assertDefined(this))
+        , index = toLength(min(arguments[1], that.length));
+      searchString += '';
+      return that.slice(index, index + searchString.length) === searchString;
+    }
+  });
+}(String.fromCharCode);
+
+/******************************************************************************
+ * Module : es6.array.statics                                                 *
+ ******************************************************************************/
+
+!function(){
+  $define(STATIC + FORCED * checkDangerIterClosing(Array.from), ARRAY, {
+    // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
+    from: function(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
+      var O       = Object(assertDefined(arrayLike))
+        , mapfn   = arguments[1]
+        , mapping = mapfn !== undefined
+        , f       = mapping ? ctx(mapfn, arguments[2], 2) : undefined
+        , index   = 0
+        , length, result, step;
+      if(isIterable(O)){
+        result = new (generic(this, Array));
+        safeIterClose(function(iterator){
+          for(; !(step = iterator.next()).done; index++){
+            result[index] = mapping ? f(step.value, index) : step.value;
+          }
+        }, getIterator(O));
+      } else {
+        result = new (generic(this, Array))(length = toLength(O.length));
+        for(; length > index; index++){
+          result[index] = mapping ? f(O[index], index) : O[index];
+        }
+      }
+      result.length = index;
+      return result;
+    }
+  });
+  
+  $define(STATIC, ARRAY, {
+    // 22.1.2.3 Array.of( ...items)
+    of: function(/* ...args */){
+      var index  = 0
+        , length = arguments.length
+        , result = new (generic(this, Array))(length);
+      while(length > index)result[index] = arguments[index++];
+      result.length = length;
+      return result;
+    }
+  });
+  
+  setSpecies(Array);
+}();
+
+/******************************************************************************
+ * Module : es6.array.prototype                                               *
+ ******************************************************************************/
+
+!function(){
+  $define(PROTO, ARRAY, {
+    // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
+    copyWithin: function(target /* = 0 */, start /* = 0, end = @length */){
+      var O     = Object(assertDefined(this))
+        , len   = toLength(O.length)
+        , to    = toIndex(target, len)
+        , from  = toIndex(start, len)
+        , end   = arguments[2]
+        , fin   = end === undefined ? len : toIndex(end, len)
+        , count = min(fin - from, len - to)
+        , inc   = 1;
+      if(from < to && to < from + count){
+        inc  = -1;
+        from = from + count - 1;
+        to   = to + count - 1;
+      }
+      while(count-- > 0){
+        if(from in O)O[to] = O[from];
+        else delete O[to];
+        to += inc;
+        from += inc;
+      } return O;
+    },
+    // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
+    fill: function(value /*, start = 0, end = @length */){
+      var O      = Object(assertDefined(this))
+        , length = toLength(O.length)
+        , index  = toIndex(arguments[1], length)
+        , end    = arguments[2]
+        , endPos = end === undefined ? length : toIndex(end, length);
+      while(endPos > index)O[index++] = value;
+      return O;
+    },
+    // 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
+    find: createArrayMethod(5),
+    // 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
+    findIndex: createArrayMethod(6)
+  });
+  
+  if(framework){
+    // 22.1.3.31 Array.prototype[@@unscopables]
+    forEach.call(array('find,findIndex,fill,copyWithin,entries,keys,values'), function(it){
+      ArrayUnscopables[it] = true;
+    });
+    SYMBOL_UNSCOPABLES in ArrayProto || hidden(ArrayProto, SYMBOL_UNSCOPABLES, ArrayUnscopables);
+  }
+}();
+
+/******************************************************************************
+ * Module : es6.iterators                                                     *
+ ******************************************************************************/
+
+!function(at){
+  // 22.1.3.4 Array.prototype.entries()
+  // 22.1.3.13 Array.prototype.keys()
+  // 22.1.3.29 Array.prototype.values()
+  // 22.1.3.30 Array.prototype[@@iterator]()
+  defineStdIterators(Array, ARRAY, function(iterated, kind){
+    set(this, ITER, {o: toObject(iterated), i: 0, k: kind});
+  // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+  }, function(){
+    var iter  = this[ITER]
+      , O     = iter.o
+      , kind  = iter.k
+      , index = iter.i++;
+    if(!O || index >= O.length){
+      iter.o = undefined;
+      return iterResult(1);
+    }
+    if(kind == KEY)  return iterResult(0, index);
+    if(kind == VALUE)return iterResult(0, O[index]);
+                     return iterResult(0, [index, O[index]]);
+  }, VALUE);
+  
+  // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+  Iterators[ARGUMENTS] = Iterators[ARRAY];
+  
+  // 21.1.3.27 String.prototype[@@iterator]()
+  defineStdIterators(String, STRING, function(iterated){
+    set(this, ITER, {o: String(iterated), i: 0});
+  // 21.1.5.2.1 %StringIteratorPrototype%.next()
+  }, function(){
+    var iter  = this[ITER]
+      , O     = iter.o
+      , index = iter.i
+      , point;
+    if(index >= O.length)return iterResult(1);
+    point = at.call(O, index);
+    iter.i += point.length;
+    return iterResult(0, point);
+  });
+}(createPointAt(true));
+
+/******************************************************************************
+ * Module : web.immediate                                                     *
+ ******************************************************************************/
+
+// setImmediate shim
+// Node.js 0.9+ & IE10+ has setImmediate, else:
+isFunction(setImmediate) && isFunction(clearImmediate) || function(ONREADYSTATECHANGE){
+  var postMessage      = global.postMessage
+    , addEventListener = global.addEventListener
+    , MessageChannel   = global.MessageChannel
+    , counter          = 0
+    , queue            = {}
+    , defer, channel, port;
+  setImmediate = function(fn){
+    var args = [], i = 1;
+    while(arguments.length > i)args.push(arguments[i++]);
+    queue[++counter] = function(){
+      invoke(isFunction(fn) ? fn : Function(fn), args);
+    }
+    defer(counter);
+    return counter;
+  }
+  clearImmediate = function(id){
+    delete queue[id];
+  }
+  function run(id){
+    if(has(queue, id)){
+      var fn = queue[id];
+      delete queue[id];
+      fn();
+    }
+  }
+  function listner(event){
+    run(event.data);
+  }
+  // Node.js 0.8-
+  if(NODE){
+    defer = function(id){
+      nextTick(part.call(run, id));
+    }
+  // Modern browsers, skip implementation for WebWorkers
+  // IE8 has postMessage, but it's sync & typeof its postMessage is object
+  } else if(addEventListener && isFunction(postMessage) && !global.importScripts){
+    defer = function(id){
+      postMessage(id, '*');
+    }
+    addEventListener('message', listner, false);
+  // WebWorkers
+  } else if(isFunction(MessageChannel)){
+    channel = new MessageChannel;
+    port    = channel.port2;
+    channel.port1.onmessage = listner;
+    defer = ctx(port.postMessage, port, 1);
+  // IE8-
+  } else if(document && ONREADYSTATECHANGE in document[CREATE_ELEMENT]('script')){
+    defer = function(id){
+      html.appendChild(document[CREATE_ELEMENT]('script'))[ONREADYSTATECHANGE] = function(){
+        html.removeChild(this);
+        run(id);
+      }
+    }
+  // Rest old browsers
+  } else {
+    defer = function(id){
+      setTimeout(run, 0, id);
+    }
+  }
+}('onreadystatechange');
+$define(GLOBAL + BIND, {
+  setImmediate:   setImmediate,
+  clearImmediate: clearImmediate
+});
+
+/******************************************************************************
+ * Module : es6.promise                                                       *
+ ******************************************************************************/
+
+// ES6 promises shim
+// Based on https://github.com/getify/native-promise-only/
+!function(Promise, test){
+  isFunction(Promise) && isFunction(Promise.resolve)
+  && Promise.resolve(test = new Promise(function(){})) == test
+  || function(asap, RECORD){
+    function isThenable(it){
+      var then;
+      if(isObject(it))then = it.then;
+      return isFunction(then) ? then : false;
+    }
+    function handledRejectionOrHasOnRejected(promise){
+      var record = promise[RECORD]
+        , chain  = record.c
+        , i      = 0
+        , react;
+      if(record.h)return true;
+      while(chain.length > i){
+        react = chain[i++];
+        if(react.fail || handledRejectionOrHasOnRejected(react.P))return true;
+      }
+    }
+    function notify(record, reject){
+      var chain = record.c;
+      if(reject || chain.length)asap(function(){
+        var promise = record.p
+          , value   = record.v
+          , ok      = record.s == 1
+          , i       = 0;
+        if(reject && !handledRejectionOrHasOnRejected(promise)){
+          setTimeout(function(){
+            if(!handledRejectionOrHasOnRejected(promise)){
+              if(NODE){
+                if(!process.emit('unhandledRejection', value, promise)){
+                  // default node.js behavior
+                }
+              } else if(isFunction(console.error)){
+                console.error('Unhandled promise rejection', value);
+              }
+            }
+          }, 1e3);
+        } else while(chain.length > i)!function(react){
+          var cb = ok ? react.ok : react.fail
+            , ret, then;
+          try {
+            if(cb){
+              if(!ok)record.h = true;
+              ret = cb === true ? value : cb(value);
+              if(ret === react.P){
+                react.rej(TypeError(PROMISE + '-chain cycle'));
+              } else if(then = isThenable(ret)){
+                then.call(ret, react.res, react.rej);
+              } else react.res(ret);
+            } else react.rej(value);
+          } catch(err){
+            react.rej(err);
+          }
+        }(chain[i++]);
+        chain.length = 0;
+      });
+    }
+    function resolve(value){
+      var record = this
+        , then, wrapper;
+      if(record.d)return;
+      record.d = true;
+      record = record.r || record; // unwrap
+      try {
+        if(then = isThenable(value)){
+          wrapper = {r: record, d: false}; // wrap
+          then.call(value, ctx(resolve, wrapper, 1), ctx(reject, wrapper, 1));
+        } else {
+          record.v = value;
+          record.s = 1;
+          notify(record);
+        }
+      } catch(err){
+        reject.call(wrapper || {r: record, d: false}, err); // wrap
+      }
+    }
+    function reject(value){
+      var record = this;
+      if(record.d)return;
+      record.d = true;
+      record = record.r || record; // unwrap
+      record.v = value;
+      record.s = 2;
+      notify(record, true);
+    }
+    function getConstructor(C){
+      var S = assertObject(C)[SYMBOL_SPECIES];
+      return S != undefined ? S : C;
+    }
+    // 25.4.3.1 Promise(executor)
+    Promise = function(executor){
+      assertFunction(executor);
+      assertInstance(this, Promise, PROMISE);
+      var record = {
+        p: this,      // promise
+        c: [],        // chain
+        s: 0,         // state
+        d: false,     // done
+        v: undefined, // value
+        h: false      // handled rejection
+      };
+      hidden(this, RECORD, record);
+      try {
+        executor(ctx(resolve, record, 1), ctx(reject, record, 1));
+      } catch(err){
+        reject.call(record, err);
+      }
+    }
+    assignHidden(Promise[PROTOTYPE], {
+      // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
+      then: function(onFulfilled, onRejected){
+        var S = assertObject(assertObject(this)[CONSTRUCTOR])[SYMBOL_SPECIES];
+        var react = {
+          ok:   isFunction(onFulfilled) ? onFulfilled : true,
+          fail: isFunction(onRejected)  ? onRejected  : false
+        } , P = react.P = new (S != undefined ? S : Promise)(function(resolve, reject){
+          react.res = assertFunction(resolve);
+          react.rej = assertFunction(reject);
+        }), record = this[RECORD];
+        record.c.push(react);
+        record.s && notify(record);
+        return P;
+      },
+      // 25.4.5.1 Promise.prototype.catch(onRejected)
+      'catch': function(onRejected){
+        return this.then(undefined, onRejected);
+      }
+    });
+    assignHidden(Promise, {
+      // 25.4.4.1 Promise.all(iterable)
+      all: function(iterable){
+        var Promise = getConstructor(this)
+          , values  = [];
+        return new Promise(function(resolve, reject){
+          forOf(iterable, false, push, values);
+          var remaining = values.length
+            , results   = Array(remaining);
+          if(remaining)forEach.call(values, function(promise, index){
+            Promise.resolve(promise).then(function(value){
+              results[index] = value;
+              --remaining || resolve(results);
+            }, reject);
+          });
+          else resolve(results);
+        });
+      },
+      // 25.4.4.4 Promise.race(iterable)
+      race: function(iterable){
+        var Promise = getConstructor(this);
+        return new Promise(function(resolve, reject){
+          forOf(iterable, false, function(promise){
+            Promise.resolve(promise).then(resolve, reject);
+          });
+        });
+      },
+      // 25.4.4.5 Promise.reject(r)
+      reject: function(r){
+        return new (getConstructor(this))(function(resolve, reject){
+          reject(r);
+        });
+      },
+      // 25.4.4.6 Promise.resolve(x)
+      resolve: function(x){
+        return isObject(x) && RECORD in x && getPrototypeOf(x) === this[PROTOTYPE]
+          ? x : new (getConstructor(this))(function(resolve, reject){
+            resolve(x);
+          });
+      }
+    });
+  }(nextTick || setImmediate, safeSymbol('record'));
+  setToStringTag(Promise, PROMISE);
+  setSpecies(Promise);
+  $define(GLOBAL + FORCED * !isNative(Promise), {Promise: Promise});
+}(global[PROMISE]);
+
+/******************************************************************************
+ * Module : es6.collections                                                   *
+ ******************************************************************************/
+
+// ECMAScript 6 collections shim
+!function(){
+  var UID   = safeSymbol('uid')
+    , O1    = safeSymbol('O1')
+    , WEAK  = safeSymbol('weak')
+    , LEAK  = safeSymbol('leak')
+    , LAST  = safeSymbol('last')
+    , FIRST = safeSymbol('first')
+    , SIZE  = DESC ? safeSymbol('size') : 'size'
+    , uid   = 0
+    , tmp   = {};
+  
+  function getCollection(C, NAME, methods, commonMethods, isMap, isWeak){
+    var ADDER = isMap ? 'set' : 'add'
+      , proto = C && C[PROTOTYPE]
+      , O     = {};
+    function initFromIterable(that, iterable){
+      if(iterable != undefined)forOf(iterable, isMap, that[ADDER], that);
+      return that;
+    }
+    function fixSVZ(key, chain){
+      var method = proto[key];
+      if(framework)proto[key] = function(a, b){
+        var result = method.call(this, a === 0 ? 0 : a, b);
+        return chain ? this : result;
+      };
+    }
+    if(!isNative(C) || !(isWeak || (!BUGGY_ITERATORS && has(proto, FOR_EACH) && has(proto, 'entries')))){
+      // create collection constructor
+      C = isWeak
+        ? function(iterable){
+            assertInstance(this, C, NAME);
+            set(this, UID, uid++);
+            initFromIterable(this, iterable);
+          }
+        : function(iterable){
+            var that = this;
+            assertInstance(that, C, NAME);
+            set(that, O1, create(null));
+            set(that, SIZE, 0);
+            set(that, LAST, undefined);
+            set(that, FIRST, undefined);
+            initFromIterable(that, iterable);
+          };
+      assignHidden(assignHidden(C[PROTOTYPE], methods), commonMethods);
+      isWeak || !DESC || defineProperty(C[PROTOTYPE], 'size', {get: function(){
+        return assertDefined(this[SIZE]);
+      }});
+    } else {
+      var Native = C
+        , inst   = new C
+        , chain  = inst[ADDER](isWeak ? {} : -0, 1)
+        , buggyZero;
+      // wrap to init collections from iterable
+      if(checkDangerIterClosing(function(O){ new C(O) })){
+        C = function(iterable){
+          assertInstance(this, C, NAME);
+          return initFromIterable(new Native, iterable);
+        }
+        C[PROTOTYPE] = proto;
+        if(framework)proto[CONSTRUCTOR] = C;
+      }
+      isWeak || inst[FOR_EACH](function(val, key){
+        buggyZero = 1 / key === -Infinity;
+      });
+      // fix converting -0 key to +0
+      if(buggyZero){
+        fixSVZ('delete');
+        fixSVZ('has');
+        isMap && fixSVZ('get');
+      }
+      // + fix .add & .set for chaining
+      if(buggyZero || chain !== inst)fixSVZ(ADDER, true);
+    }
+    setToStringTag(C, NAME);
+    setSpecies(C);
+    
+    O[NAME] = C;
+    $define(GLOBAL + WRAP + FORCED * !isNative(C), O);
+    
+    // add .keys, .values, .entries, [@@iterator]
+    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
+    isWeak || defineStdIterators(C, NAME, function(iterated, kind){
+      set(this, ITER, {o: iterated, k: kind});
+    }, function(){
+      var iter  = this[ITER]
+        , kind  = iter.k
+        , entry = iter.l;
+      // revert to the last existing entry
+      while(entry && entry.r)entry = entry.p;
+      // get next entry
+      if(!iter.o || !(iter.l = entry = entry ? entry.n : iter.o[FIRST])){
+        // or finish the iteration
+        iter.o = undefined;
+        return iterResult(1);
+      }
+      // return step by kind
+      if(kind == KEY)  return iterResult(0, entry.k);
+      if(kind == VALUE)return iterResult(0, entry.v);
+                       return iterResult(0, [entry.k, entry.v]);   
+    }, isMap ? KEY+VALUE : VALUE, !isMap);
+    
+    return C;
+  }
+  
+  function fastKey(it, create){
+    // return primitive with prefix
+    if(!isObject(it))return (typeof it == 'string' ? 'S' : 'P') + it;
+    // can't set id to frozen object
+    if(isFrozen(it))return 'F';
+    if(!has(it, UID)){
+      // not necessary to add id
+      if(!create)return 'E';
+      // add missing object id
+      hidden(it, UID, ++uid);
+    // return object id with prefix
+    } return 'O' + it[UID];
+  }
+  function getEntry(that, key){
+    // fast case
+    var index = fastKey(key), entry;
+    if(index != 'F')return that[O1][index];
+    // frozen object case
+    for(entry = that[FIRST]; entry; entry = entry.n){
+      if(entry.k == key)return entry;
+    }
+  }
+  function def(that, key, value){
+    var entry = getEntry(that, key)
+      , prev, index;
+    // change existing entry
+    if(entry)entry.v = value;
+    // create new entry
+    else {
+      that[LAST] = entry = {
+        i: index = fastKey(key, true), // <- index
+        k: key,                        // <- key
+        v: value,                      // <- value
+        p: prev = that[LAST],          // <- previous entry
+        n: undefined,                  // <- next entry
+        r: false                       // <- removed
+      };
+      if(!that[FIRST])that[FIRST] = entry;
+      if(prev)prev.n = entry;
+      that[SIZE]++;
+      // add to index
+      if(index != 'F')that[O1][index] = entry;
+    } return that;
+  }
+
+  var collectionMethods = {
+    // 23.1.3.1 Map.prototype.clear()
+    // 23.2.3.2 Set.prototype.clear()
+    clear: function(){
+      for(var that = this, data = that[O1], entry = that[FIRST]; entry; entry = entry.n){
+        entry.r = true;
+        if(entry.p)entry.p = entry.p.n = undefined;
+        delete data[entry.i];
+      }
+      that[FIRST] = that[LAST] = undefined;
+      that[SIZE] = 0;
+    },
+    // 23.1.3.3 Map.prototype.delete(key)
+    // 23.2.3.4 Set.prototype.delete(value)
+    'delete': function(key){
+      var that  = this
+        , entry = getEntry(that, key);
+      if(entry){
+        var next = entry.n
+          , prev = entry.p;
+        delete that[O1][entry.i];
+        entry.r = true;
+        if(prev)prev.n = next;
+        if(next)next.p = prev;
+        if(that[FIRST] == entry)that[FIRST] = next;
+        if(that[LAST] == entry)that[LAST] = prev;
+        that[SIZE]--;
+      } return !!entry;
+    },
+    // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
+    // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
+    forEach: function(callbackfn /*, that = undefined */){
+      var f = ctx(callbackfn, arguments[1], 3)
+        , entry;
+      while(entry = entry ? entry.n : this[FIRST]){
+        f(entry.v, entry.k, this);
+        // revert to the last existing entry
+        while(entry && entry.r)entry = entry.p;
+      }
+    },
+    // 23.1.3.7 Map.prototype.has(key)
+    // 23.2.3.7 Set.prototype.has(value)
+    has: function(key){
+      return !!getEntry(this, key);
+    }
+  }
+  
+  // 23.1 Map Objects
+  Map = getCollection(Map, MAP, {
+    // 23.1.3.6 Map.prototype.get(key)
+    get: function(key){
+      var entry = getEntry(this, key);
+      return entry && entry.v;
+    },
+    // 23.1.3.9 Map.prototype.set(key, value)
+    set: function(key, value){
+      return def(this, key === 0 ? 0 : key, value);
+    }
+  }, collectionMethods, true);
+  
+  // 23.2 Set Objects
+  Set = getCollection(Set, SET, {
+    // 23.2.3.1 Set.prototype.add(value)
+    add: function(value){
+      return def(this, value = value === 0 ? 0 : value, value);
+    }
+  }, collectionMethods);
+  
+  function defWeak(that, key, value){
+    if(isFrozen(assertObject(key)))leakStore(that).set(key, value);
+    else {
+      has(key, WEAK) || hidden(key, WEAK, {});
+      key[WEAK][that[UID]] = value;
+    } return that;
+  }
+  function leakStore(that){
+    return that[LEAK] || hidden(that, LEAK, new Map)[LEAK];
+  }
+  
+  var weakMethods = {
+    // 23.3.3.2 WeakMap.prototype.delete(key)
+    // 23.4.3.3 WeakSet.prototype.delete(value)
+    'delete': function(key){
+      if(!isObject(key))return false;
+      if(isFrozen(key))return leakStore(this)['delete'](key);
+      return has(key, WEAK) && has(key[WEAK], this[UID]) && delete key[WEAK][this[UID]];
+    },
+    // 23.3.3.4 WeakMap.prototype.has(key)
+    // 23.4.3.4 WeakSet.prototype.has(value)
+    has: function(key){
+      if(!isObject(key))return false;
+      if(isFrozen(key))return leakStore(this).has(key);
+      return has(key, WEAK) && has(key[WEAK], this[UID]);
+    }
+  };
+  
+  // 23.3 WeakMap Objects
+  WeakMap = getCollection(WeakMap, WEAKMAP, {
+    // 23.3.3.3 WeakMap.prototype.get(key)
+    get: function(key){
+      if(isObject(key)){
+        if(isFrozen(key))return leakStore(this).get(key);
+        if(has(key, WEAK))return key[WEAK][this[UID]];
+      }
+    },
+    // 23.3.3.5 WeakMap.prototype.set(key, value)
+    set: function(key, value){
+      return defWeak(this, key, value);
+    }
+  }, weakMethods, true, true);
+  
+  // IE11 WeakMap frozen keys fix
+  if(framework && new WeakMap().set(Object.freeze(tmp), 7).get(tmp) != 7){
+    forEach.call(array('delete,has,get,set'), function(key){
+      var method = WeakMap[PROTOTYPE][key];
+      WeakMap[PROTOTYPE][key] = function(a, b){
+        // store frozen objects on leaky map
+        if(isObject(a) && isFrozen(a)){
+          var result = leakStore(this)[key](a, b);
+          return key == 'set' ? this : result;
+        // store all the rest on native weakmap
+        } return method.call(this, a, b);
+      };
+    });
+  }
+  
+  // 23.4 WeakSet Objects
+  WeakSet = getCollection(WeakSet, WEAKSET, {
+    // 23.4.3.1 WeakSet.prototype.add(value)
+    add: function(value){
+      return defWeak(this, value, true);
+    }
+  }, weakMethods, false, true);
+}();
+
+/******************************************************************************
+ * Module : es6.reflect                                                       *
+ ******************************************************************************/
+
+!function(){
+  function Enumerate(iterated){
+    var keys = [], key;
+    for(key in iterated)keys.push(key);
+    set(this, ITER, {o: iterated, a: keys, i: 0});
+  }
+  createIterator(Enumerate, OBJECT, function(){
+    var iter = this[ITER]
+      , keys = iter.a
+      , key;
+    do {
+      if(iter.i >= keys.length)return iterResult(1);
+    } while(!((key = keys[iter.i++]) in iter.o));
+    return iterResult(0, key);
+  });
+  
+  function wrap(fn){
+    return function(it){
+      assertObject(it);
+      try {
+        return fn.apply(undefined, arguments), true;
+      } catch(e){
+        return false;
+      }
+    }
+  }
+  
+  function reflectGet(target, propertyKey/*, receiver*/){
+    var receiver = arguments.length < 3 ? target : arguments[2]
+      , desc = getOwnDescriptor(assertObject(target), propertyKey), proto;
+    if(desc)return has(desc, 'value')
+      ? desc.value
+      : desc.get === undefined
+        ? undefined
+        : desc.get.call(receiver);
+    return isObject(proto = getPrototypeOf(target))
+      ? reflectGet(proto, propertyKey, receiver)
+      : undefined;
+  }
+  function reflectSet(target, propertyKey, V/*, receiver*/){
+    var receiver = arguments.length < 4 ? target : arguments[3]
+      , ownDesc  = getOwnDescriptor(assertObject(target), propertyKey)
+      , existingDescriptor, proto;
+    if(!ownDesc){
+      if(isObject(proto = getPrototypeOf(target))){
+        return reflectSet(proto, propertyKey, V, receiver);
+      }
+      ownDesc = descriptor(0);
+    }
+    if(has(ownDesc, 'value')){
+      if(ownDesc.writable === false || !isObject(receiver))return false;
+      existingDescriptor = getOwnDescriptor(receiver, propertyKey) || descriptor(0);
+      existingDescriptor.value = V;
+      return defineProperty(receiver, propertyKey, existingDescriptor), true;
+    }
+    return ownDesc.set === undefined
+      ? false
+      : (ownDesc.set.call(receiver, V), true);
+  }
+  var isExtensible = Object.isExtensible || returnIt;
+  
+  var reflect = {
+    // 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
+    apply: ctx(call, apply, 3),
+    // 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
+    construct: function(target, argumentsList /*, newTarget*/){
+      var proto    = assertFunction(arguments.length < 3 ? target : arguments[2])[PROTOTYPE]
+        , instance = create(isObject(proto) ? proto : ObjectProto)
+        , result   = apply.call(target, instance, argumentsList);
+      return isObject(result) ? result : instance;
+    },
+    // 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
+    defineProperty: wrap(defineProperty),
+    // 26.1.4 Reflect.deleteProperty(target, propertyKey)
+    deleteProperty: function(target, propertyKey){
+      var desc = getOwnDescriptor(assertObject(target), propertyKey);
+      return desc && !desc.configurable ? false : delete target[propertyKey];
+    },
+    // 26.1.5 Reflect.enumerate(target)
+    enumerate: function(target){
+      return new Enumerate(assertObject(target));
+    },
+    // 26.1.6 Reflect.get(target, propertyKey [, receiver])
+    get: reflectGet,
+    // 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
+    getOwnPropertyDescriptor: function(target, propertyKey){
+      return getOwnDescriptor(assertObject(target), propertyKey);
+    },
+    // 26.1.8 Reflect.getPrototypeOf(target)
+    getPrototypeOf: function(target){
+      return getPrototypeOf(assertObject(target));
+    },
+    // 26.1.9 Reflect.has(target, propertyKey)
+    has: function(target, propertyKey){
+      return propertyKey in target;
+    },
+    // 26.1.10 Reflect.isExtensible(target)
+    isExtensible: function(target){
+      return !!isExtensible(assertObject(target));
+    },
+    // 26.1.11 Reflect.ownKeys(target)
+    ownKeys: ownKeys,
+    // 26.1.12 Reflect.preventExtensions(target)
+    preventExtensions: wrap(Object.preventExtensions || returnIt),
+    // 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
+    set: reflectSet
+  }
+  // 26.1.14 Reflect.setPrototypeOf(target, proto)
+  if(setPrototypeOf)reflect.setPrototypeOf = function(target, proto){
+    return setPrototypeOf(assertObject(target), proto), true;
+  };
+  
+  $define(GLOBAL, {Reflect: {}});
+  $define(STATIC, 'Reflect', reflect);
+}();
+
+/******************************************************************************
+ * Module : es7.proposals                                                     *
+ ******************************************************************************/
+
+!function(){
+  $define(PROTO, ARRAY, {
+    // https://github.com/domenic/Array.prototype.includes
+    includes: createArrayContains(true)
+  });
+  $define(PROTO, STRING, {
+    // https://github.com/mathiasbynens/String.prototype.at
+    at: createPointAt(true)
+  });
+  
+  function createObjectToArray(isEntries){
+    return function(object){
+      var O      = toObject(object)
+        , keys   = getKeys(object)
+        , length = keys.length
+        , i      = 0
+        , result = Array(length)
+        , key;
+      if(isEntries)while(length > i)result[i] = [key = keys[i++], O[key]];
+      else while(length > i)result[i] = O[keys[i++]];
+      return result;
+    }
+  }
+  $define(STATIC, OBJECT, {
+    // https://gist.github.com/WebReflection/9353781
+    getOwnPropertyDescriptors: function(object){
+      var O      = toObject(object)
+        , result = {};
+      forEach.call(ownKeys(O), function(key){
+        defineProperty(result, key, descriptor(0, getOwnDescriptor(O, key)));
+      });
+      return result;
+    },
+    // https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-04/apr-9.md#51-objectentries-objectvalues
+    values:  createObjectToArray(false),
+    entries: createObjectToArray(true)
+  });
+  $define(STATIC, REGEXP, {
+    // https://gist.github.com/kangax/9698100
+    escape: createReplacer(/([\\\-[\]{}()*+?.,^$|])/g, '\\$1', true)
+  });
+}();
+
+/******************************************************************************
+ * Module : es7.abstract-refs                                                 *
+ ******************************************************************************/
+
+// https://github.com/zenparsing/es-abstract-refs
+!function(REFERENCE){
+  REFERENCE_GET = getWellKnownSymbol(REFERENCE+'Get', true);
+  var REFERENCE_SET = getWellKnownSymbol(REFERENCE+SET, true)
+    , REFERENCE_DELETE = getWellKnownSymbol(REFERENCE+'Delete', true);
+  
+  $define(STATIC, SYMBOL, {
+    referenceGet: REFERENCE_GET,
+    referenceSet: REFERENCE_SET,
+    referenceDelete: REFERENCE_DELETE
+  });
+  
+  hidden(FunctionProto, REFERENCE_GET, returnThis);
+  
+  function setMapMethods(Constructor){
+    if(Constructor){
+      var MapProto = Constructor[PROTOTYPE];
+      hidden(MapProto, REFERENCE_GET, MapProto.get);
+      hidden(MapProto, REFERENCE_SET, MapProto.set);
+      hidden(MapProto, REFERENCE_DELETE, MapProto['delete']);
+    }
+  }
+  setMapMethods(Map);
+  setMapMethods(WeakMap);
+}('reference');
+
+/******************************************************************************
+ * Module : core.dict                                                         *
+ ******************************************************************************/
+
+!function(DICT){
+  Dict = function(iterable){
+    var dict = create(null);
+    if(iterable != undefined){
+      if(isIterable(iterable)){
+        forOf(iterable, true, function(key, value){
+          dict[key] = value;
+        });
+      } else assign(dict, iterable);
+    }
+    return dict;
+  }
+  Dict[PROTOTYPE] = null;
+  
+  function DictIterator(iterated, kind){
+    set(this, ITER, {o: toObject(iterated), a: getKeys(iterated), i: 0, k: kind});
+  }
+  createIterator(DictIterator, DICT, function(){
+    var iter = this[ITER]
+      , O    = iter.o
+      , keys = iter.a
+      , kind = iter.k
+      , key;
+    do {
+      if(iter.i >= keys.length){
+        iter.o = undefined;
+        return iterResult(1);
+      }
+    } while(!has(O, key = keys[iter.i++]));
+    if(kind == KEY)  return iterResult(0, key);
+    if(kind == VALUE)return iterResult(0, O[key]);
+                     return iterResult(0, [key, O[key]]);
+  });
+  function createDictIter(kind){
+    return function(it){
+      return new DictIterator(it, kind);
+    }
+  }
+  
+  /*
+   * 0 -> forEach
+   * 1 -> map
+   * 2 -> filter
+   * 3 -> some
+   * 4 -> every
+   * 5 -> find
+   * 6 -> findKey
+   * 7 -> mapPairs
+   */
+  function createDictMethod(type){
+    var isMap    = type == 1
+      , isEvery  = type == 4;
+    return function(object, callbackfn, that /* = undefined */){
+      var f      = ctx(callbackfn, that, 3)
+        , O      = toObject(object)
+        , result = isMap || type == 7 || type == 2 ? new (generic(this, Dict)) : undefined
+        , key, val, res;
+      for(key in O)if(has(O, key)){
+        val = O[key];
+        res = f(val, key, object);
+        if(type){
+          if(isMap)result[key] = res;             // map
+          else if(res)switch(type){
+            case 2: result[key] = val; break      // filter
+            case 3: return true;                  // some
+            case 5: return val;                   // find
+            case 6: return key;                   // findKey
+            case 7: result[res[0]] = res[1];      // mapPairs
+          } else if(isEvery)return false;         // every
+        }
+      }
+      return type == 3 || isEvery ? isEvery : result;
+    }
+  }
+  function createDictReduce(isTurn){
+    return function(object, mapfn, init){
+      assertFunction(mapfn);
+      var O      = toObject(object)
+        , keys   = getKeys(O)
+        , length = keys.length
+        , i      = 0
+        , memo, key, result;
+      if(isTurn)memo = init == undefined ? new (generic(this, Dict)) : Object(init);
+      else if(arguments.length < 3){
+        assert(length, REDUCE_ERROR);
+        memo = O[keys[i++]];
+      } else memo = Object(init);
+      while(length > i)if(has(O, key = keys[i++])){
+        result = mapfn(memo, O[key], key, object);
+        if(isTurn){
+          if(result === false)break;
+        } else memo = result;
+      }
+      return memo;
+    }
+  }
+  var findKey = createDictMethod(6);
+  function includes(object, el){
+    return (el == el ? keyOf(object, el) : findKey(object, sameNaN)) !== undefined;
+  }
+  
+  var dictMethods = {
+    keys:    createDictIter(KEY),
+    values:  createDictIter(VALUE),
+    entries: createDictIter(KEY+VALUE),
+    forEach: createDictMethod(0),
+    map:     createDictMethod(1),
+    filter:  createDictMethod(2),
+    some:    createDictMethod(3),
+    every:   createDictMethod(4),
+    find:    createDictMethod(5),
+    findKey: findKey,
+    mapPairs:createDictMethod(7),
+    reduce:  createDictReduce(false),
+    turn:    createDictReduce(true),
+    keyOf:   keyOf,
+    includes:includes,
+    // Has / get / set own property
+    has: has,
+    get: get,
+    set: createDefiner(0),
+    isDict: function(it){
+      return isObject(it) && getPrototypeOf(it) === Dict[PROTOTYPE];
+    }
+  };
+  
+  if(REFERENCE_GET)for(var key in dictMethods)!function(fn){
+    function method(){
+      for(var args = [this], i = 0; i < arguments.length;)args.push(arguments[i++]);
+      return invoke(fn, args);
+    }
+    fn[REFERENCE_GET] = function(){
+      return method;
+    }
+  }(dictMethods[key]);
+  
+  $define(GLOBAL + FORCED, {Dict: assignHidden(Dict, dictMethods)});
+}('Dict');
+
+/******************************************************************************
+ * Module : core.$for                                                         *
+ ******************************************************************************/
+
+!function(ENTRIES, FN){  
+  function $for(iterable, entries){
+    if(!(this instanceof $for))return new $for(iterable, entries);
+    this[ITER]    = getIterator(iterable);
+    this[ENTRIES] = !!entries;
+  }
+  
+  createIterator($for, 'Wrapper', function(){
+    return this[ITER].next();
+  });
+  var $forProto = $for[PROTOTYPE];
+  setIterator($forProto, function(){
+    return this[ITER]; // unwrap
+  });
+  
+  function createChainIterator(next){
+    function Iter(I, fn, that){
+      this[ITER]    = getIterator(I);
+      this[ENTRIES] = I[ENTRIES];
+      this[FN]      = ctx(fn, that, I[ENTRIES] ? 2 : 1);
+    }
+    createIterator(Iter, 'Chain', next, $forProto);
+    setIterator(Iter[PROTOTYPE], returnThis); // override $forProto iterator
+    return Iter;
+  }
+  
+  var MapIter = createChainIterator(function(){
+    var step = this[ITER].next();
+    return step.done ? step : iterResult(0, stepCall(this[FN], step.value, this[ENTRIES]));
+  });
+  
+  var FilterIter = createChainIterator(function(){
+    for(;;){
+      var step = this[ITER].next();
+      if(step.done || stepCall(this[FN], step.value, this[ENTRIES]))return step;
+    }
+  });
+  
+  assignHidden($forProto, {
+    of: function(fn, that){
+      forOf(this, this[ENTRIES], fn, that);
+    },
+    array: function(fn, that){
+      var result = [];
+      forOf(fn != undefined ? this.map(fn, that) : this, false, push, result);
+      return result;
+    },
+    filter: function(fn, that){
+      return new FilterIter(this, fn, that);
+    },
+    map: function(fn, that){
+      return new MapIter(this, fn, that);
+    }
+  });
+  
+  $for.isIterable  = isIterable;
+  $for.getIterator = getIterator;
+  
+  $define(GLOBAL + FORCED, {$for: $for});
+}('entries', safeSymbol('fn'));
+
+/******************************************************************************
+ * Module : core.delay                                                        *
+ ******************************************************************************/
+
+// https://esdiscuss.org/topic/promise-returning-delay-function
+$define(GLOBAL + FORCED, {
+  delay: function(time){
+    return new Promise(function(resolve){
+      setTimeout(resolve, time, true);
+    });
+  }
+});
+
+/******************************************************************************
+ * Module : core.binding                                                      *
+ ******************************************************************************/
+
+!function(_, toLocaleString){
+  // Placeholder
+  core._ = path._ = path._ || {};
+
+  $define(PROTO + FORCED, FUNCTION, {
+    part: part,
+    only: function(numberArguments, that /* = @ */){
+      var fn     = assertFunction(this)
+        , n      = toLength(numberArguments)
+        , isThat = arguments.length > 1;
+      return function(/* ...args */){
+        var length = min(n, arguments.length)
+          , args   = Array(length)
+          , i      = 0;
+        while(length > i)args[i] = arguments[i++];
+        return invoke(fn, args, isThat ? that : this);
+      }
+    }
+  });
+  
+  function tie(key){
+    var that  = this
+      , bound = {};
+    return hidden(that, _, function(key){
+      if(key === undefined || !(key in that))return toLocaleString.call(that);
+      return has(bound, key) ? bound[key] : (bound[key] = ctx(that[key], that, -1));
+    })[_](key);
+  }
+  
+  hidden(path._, TO_STRING, function(){
+    return _;
+  });
+  
+  hidden(ObjectProto, _, tie);
+  DESC || hidden(ArrayProto, _, tie);
+  // IE8- dirty hack - redefined toLocaleString is not enumerable
+}(DESC ? uid('tie') : TO_LOCALE, ObjectProto[TO_LOCALE]);
+
+/******************************************************************************
+ * Module : core.object                                                       *
+ ******************************************************************************/
+
+!function(){
+  function define(target, mixin){
+    var keys   = ownKeys(toObject(mixin))
+      , length = keys.length
+      , i = 0, key;
+    while(length > i)defineProperty(target, key = keys[i++], getOwnDescriptor(mixin, key));
+    return target;
+  };
+  $define(STATIC + FORCED, OBJECT, {
+    isObject: isObject,
+    classof: classof,
+    define: define,
+    make: function(proto, mixin){
+      return define(create(proto), mixin);
+    }
+  });
+}();
+
+/******************************************************************************
+ * Module : core.array                                                        *
+ ******************************************************************************/
+
+$define(PROTO + FORCED, ARRAY, {
+  turn: function(fn, target /* = [] */){
+    assertFunction(fn);
+    var memo   = target == undefined ? [] : Object(target)
+      , O      = ES5Object(this)
+      , length = toLength(O.length)
+      , index  = 0;
+    while(length > index)if(fn(memo, O[index], index++, this) === false)break;
+    return memo;
+  }
+});
+if(framework)ArrayUnscopables.turn = true;
+
+/******************************************************************************
+ * Module : core.number                                                       *
+ ******************************************************************************/
+
+!function(numberMethods){  
+  function NumberIterator(iterated){
+    set(this, ITER, {l: toLength(iterated), i: 0});
+  }
+  createIterator(NumberIterator, NUMBER, function(){
+    var iter = this[ITER]
+      , i    = iter.i++;
+    return i < iter.l ? iterResult(0, i) : iterResult(1);
+  });
+  defineIterator(Number, NUMBER, function(){
+    return new NumberIterator(this);
+  });
+  
+  numberMethods.random = function(lim /* = 0 */){
+    var a = +this
+      , b = lim == undefined ? 0 : +lim
+      , m = min(a, b);
+    return random() * (max(a, b) - m) + m;
+  };
+
+  forEach.call(array(
+      // ES3:
+      'round,floor,ceil,abs,sin,asin,cos,acos,tan,atan,exp,sqrt,max,min,pow,atan2,' +
+      // ES6:
+      'acosh,asinh,atanh,cbrt,clz32,cosh,expm1,hypot,imul,log1p,log10,log2,sign,sinh,tanh,trunc'
+    ), function(key){
+      var fn = Math[key];
+      if(fn)numberMethods[key] = function(/* ...args */){
+        // ie9- dont support strict mode & convert `this` to object -> convert it to number
+        var args = [+this]
+          , i    = 0;
+        while(arguments.length > i)args.push(arguments[i++]);
+        return invoke(fn, args);
+      }
+    }
+  );
+  
+  $define(PROTO + FORCED, NUMBER, numberMethods);
+}({});
+
+/******************************************************************************
+ * Module : core.string                                                       *
+ ******************************************************************************/
+
+!function(){
+  var escapeHTMLDict = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&apos;'
+  }, unescapeHTMLDict = {}, key;
+  for(key in escapeHTMLDict)unescapeHTMLDict[escapeHTMLDict[key]] = key;
+  $define(PROTO + FORCED, STRING, {
+    escapeHTML:   createReplacer(/[&<>"']/g, escapeHTMLDict),
+    unescapeHTML: createReplacer(/&(?:amp|lt|gt|quot|apos);/g, unescapeHTMLDict)
+  });
+}();
+
+/******************************************************************************
+ * Module : core.date                                                         *
+ ******************************************************************************/
+
+!function(formatRegExp, flexioRegExp, locales, current, SECONDS, MINUTES, HOURS, MONTH, YEAR){
+  function createFormat(prefix){
+    return function(template, locale /* = current */){
+      var that = this
+        , dict = locales[has(locales, locale) ? locale : current];
+      function get(unit){
+        return that[prefix + unit]();
+      }
+      return String(template).replace(formatRegExp, function(part){
+        switch(part){
+          case 's'  : return get(SECONDS);                  // Seconds : 0-59
+          case 'ss' : return lz(get(SECONDS));              // Seconds : 00-59
+          case 'm'  : return get(MINUTES);                  // Minutes : 0-59
+          case 'mm' : return lz(get(MINUTES));              // Minutes : 00-59
+          case 'h'  : return get(HOURS);                    // Hours   : 0-23
+          case 'hh' : return lz(get(HOURS));                // Hours   : 00-23
+          case 'D'  : return get(DATE);                     // Date    : 1-31
+          case 'DD' : return lz(get(DATE));                 // Date    : 01-31
+          case 'W'  : return dict[0][get('Day')];           // Day     : Понедельник
+          case 'N'  : return get(MONTH) + 1;                // Month   : 1-12
+          case 'NN' : return lz(get(MONTH) + 1);            // Month   : 01-12
+          case 'M'  : return dict[2][get(MONTH)];           // Month   : Январь
+          case 'MM' : return dict[1][get(MONTH)];           // Month   : Января
+          case 'Y'  : return get(YEAR);                     // Year    : 2014
+          case 'YY' : return lz(get(YEAR) % 100);           // Year    : 14
+        } return part;
+      });
+    }
+  }
+  function addLocale(lang, locale){
+    function split(index){
+      var result = [];
+      forEach.call(array(locale.months), function(it){
+        result.push(it.replace(flexioRegExp, '$' + index));
+      });
+      return result;
+    }
+    locales[lang] = [array(locale.weekdays), split(1), split(2)];
+    return core;
+  }
+  $define(PROTO + FORCED, DATE, {
+    format:    createFormat('get'),
+    formatUTC: createFormat('getUTC')
+  });
+  addLocale(current, {
+    weekdays: 'Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday',
+    months: 'January,February,March,April,May,June,July,August,September,October,November,December'
+  });
+  addLocale('ru', {
+    weekdays: 'Воскресенье,Понедельник,Вторник,Среда,Четверг,Пятница,Суббота',
+    months: 'Январ:я|ь,Феврал:я|ь,Март:а|,Апрел:я|ь,Ма:я|й,Июн:я|ь,' +
+            'Июл:я|ь,Август:а|,Сентябр:я|ь,Октябр:я|ь,Ноябр:я|ь,Декабр:я|ь'
+  });
+  core.locale = function(locale){
+    return has(locales, locale) ? current = locale : current;
+  };
+  core.addLocale = addLocale;
+}(/\b\w\w?\b/g, /:(.*)\|(.*)$/, {}, 'en', 'Seconds', 'Minutes', 'Hours', 'Month', 'FullYear');
+
+/******************************************************************************
+ * Module : core.global                                                       *
+ ******************************************************************************/
+
+$define(GLOBAL + FORCED, {global: global});
+
+/******************************************************************************
+ * Module : js.array.statics                                                  *
+ ******************************************************************************/
+
+// JavaScript 1.6 / Strawman array statics shim
+!function(arrayStatics){
+  function setArrayStatics(keys, length){
+    forEach.call(array(keys), function(key){
+      if(key in ArrayProto)arrayStatics[key] = ctx(call, ArrayProto[key], length);
+    });
+  }
+  setArrayStatics('pop,reverse,shift,keys,values,entries', 1);
+  setArrayStatics('indexOf,every,some,forEach,map,filter,find,findIndex,includes', 3);
+  setArrayStatics('join,slice,concat,push,splice,unshift,sort,lastIndexOf,' +
+                  'reduce,reduceRight,copyWithin,fill,turn');
+  $define(STATIC, ARRAY, arrayStatics);
+}({});
+
+/******************************************************************************
+ * Module : web.dom.itarable                                                  *
+ ******************************************************************************/
+
+!function(NodeList){
+  if(framework && NodeList && !(SYMBOL_ITERATOR in NodeList[PROTOTYPE])){
+    hidden(NodeList[PROTOTYPE], SYMBOL_ITERATOR, Iterators[ARRAY]);
+  }
+  Iterators.NodeList = Iterators[ARRAY];
+}(global.NodeList);
+
+/******************************************************************************
+ * Module : core.log                                                          *
+ ******************************************************************************/
+
+!function(log, enabled){
+  // Methods from https://github.com/DeveloperToolsWG/console-object/blob/master/api.md
+  forEach.call(array('assert,clear,count,debug,dir,dirxml,error,exception,' +
+      'group,groupCollapsed,groupEnd,info,isIndependentlyComposed,log,' +
+      'markTimeline,profile,profileEnd,table,time,timeEnd,timeline,' +
+      'timelineEnd,timeStamp,trace,warn'), function(key){
+    log[key] = function(){
+      if(enabled && key in console)return apply.call(console[key], console, arguments);
+    };
+  });
+  $define(GLOBAL + FORCED, {log: assign(log.log, log, {
+    enable: function(){
+      enabled = true;
+    },
+    disable: function(){
+      enabled = false;
+    }
+  })});
+}({}, true);
+}(typeof self != 'undefined' && self.Math === Math ? self : Function('return this')(), false);
+},{}],173:[function(require,module,exports){
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = debug;
+exports.coerce = coerce;
+exports.disable = disable;
+exports.enable = enable;
+exports.enabled = enabled;
+exports.humanize = require('ms');
+
+/**
+ * The currently active debug mode names, and names to skip.
+ */
+
+exports.names = [];
+exports.skips = [];
+
+/**
+ * Map of special "%n" handling functions, for the debug "format" argument.
+ *
+ * Valid key names are a single, lowercased letter, i.e. "n".
+ */
+
+exports.formatters = {};
+
+/**
+ * Previously assigned color.
+ */
+
+var prevColor = 0;
+
+/**
+ * Previous log timestamp.
+ */
+
+var prevTime;
+
+/**
+ * Select a color.
+ *
+ * @return {Number}
+ * @api private
+ */
+
+function selectColor() {
+  return exports.colors[prevColor++ % exports.colors.length];
+}
+
+/**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
+
+function debug(namespace) {
+
+  // define the `disabled` version
+  function disabled() {
+  }
+  disabled.enabled = false;
+
+  // define the `enabled` version
+  function enabled() {
+
+    var self = enabled;
+
+    // set `diff` timestamp
+    var curr = +new Date();
+    var ms = curr - (prevTime || curr);
+    self.diff = ms;
+    self.prev = prevTime;
+    self.curr = curr;
+    prevTime = curr;
+
+    // add the `color` if not set
+    if (null == self.useColors) self.useColors = exports.useColors();
+    if (null == self.color && self.useColors) self.color = selectColor();
+
+    var args = Array.prototype.slice.call(arguments);
+
+    args[0] = exports.coerce(args[0]);
+
+    if ('string' !== typeof args[0]) {
+      // anything else let's inspect with %o
+      args = ['%o'].concat(args);
+    }
+
+    // apply any `formatters` transformations
+    var index = 0;
+    args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {
+      // if we encounter an escaped % then don't increase the array index
+      if (match === '%%') return match;
+      index++;
+      var formatter = exports.formatters[format];
+      if ('function' === typeof formatter) {
+        var val = args[index];
+        match = formatter.call(self, val);
+
+        // now we need to remove `args[index]` since it's inlined in the `format`
+        args.splice(index, 1);
+        index--;
+      }
+      return match;
+    });
+
+    if ('function' === typeof exports.formatArgs) {
+      args = exports.formatArgs.apply(self, args);
+    }
+    var logFn = enabled.log || exports.log || console.log.bind(console);
+    logFn.apply(self, args);
+  }
+  enabled.enabled = true;
+
+  var fn = exports.enabled(namespace) ? enabled : disabled;
+
+  fn.namespace = namespace;
+
+  return fn;
+}
+
+/**
+ * Enables a debug mode by namespaces. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} namespaces
+ * @api public
+ */
+
+function enable(namespaces) {
+  exports.save(namespaces);
+
+  var split = (namespaces || '').split(/[\s,]+/);
+  var len = split.length;
+
+  for (var i = 0; i < len; i++) {
+    if (!split[i]) continue; // ignore empty strings
+    namespaces = split[i].replace(/\*/g, '.*?');
+    if (namespaces[0] === '-') {
+      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+    } else {
+      exports.names.push(new RegExp('^' + namespaces + '$'));
+    }
+  }
+}
+
+/**
+ * Disable debug output.
+ *
+ * @api public
+ */
+
+function disable() {
+  exports.enable('');
+}
+
+/**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
+
+function enabled(name) {
+  var i, len;
+  for (i = 0, len = exports.skips.length; i < len; i++) {
+    if (exports.skips[i].test(name)) {
+      return false;
+    }
+  }
+  for (i = 0, len = exports.names.length; i < len; i++) {
+    if (exports.names[i].test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Coerce `val`.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
+
+function coerce(val) {
+  if (val instanceof Error) return val.stack || val.message;
+  return val;
+}
+
+},{"ms":175}],174:[function(require,module,exports){
+(function (process){
+
+/**
+ * Module dependencies.
+ */
+
+var tty = require('tty');
+var util = require('util');
+
+/**
+ * This is the Node.js implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = require('./debug');
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+
+/**
+ * Colors.
+ */
+
+exports.colors = [6, 2, 3, 4, 5, 1];
+
+/**
+ * The file descriptor to write the `debug()` calls to.
+ * Set the `DEBUG_FD` env variable to override with another value. i.e.:
+ *
+ *   $ DEBUG_FD=3 node script.js 3>debug.log
+ */
+
+var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+var stream = 1 === fd ? process.stdout :
+             2 === fd ? process.stderr :
+             createWritableStdioStream(fd);
+
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+  var debugColors = (process.env.DEBUG_COLORS || '').trim().toLowerCase();
+  if (0 === debugColors.length) {
+    return tty.isatty(fd);
+  } else {
+    return '0' !== debugColors
+        && 'no' !== debugColors
+        && 'false' !== debugColors
+        && 'disabled' !== debugColors;
+  }
+}
+
+/**
+ * Map %o to `util.inspect()`, since Node doesn't do that out of the box.
+ */
+
+var inspect = (4 === util.inspect.length ?
+  // node <= 0.8.x
+  function (v, colors) {
+    return util.inspect(v, void 0, void 0, colors);
+  } :
+  // node > 0.8.x
+  function (v, colors) {
+    return util.inspect(v, { colors: colors });
+  }
+);
+
+exports.formatters.o = function(v) {
+  return inspect(v, this.useColors)
+    .replace(/\s*\n\s*/g, ' ');
+};
+
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs() {
+  var args = arguments;
+  var useColors = this.useColors;
+  var name = this.namespace;
+
+  if (useColors) {
+    var c = this.color;
+
+    args[0] = '  \u001b[9' + c + 'm' + name + ' '
+      + '\u001b[0m'
+      + args[0] + '\u001b[3' + c + 'm'
+      + ' +' + exports.humanize(this.diff) + '\u001b[0m';
+  } else {
+    args[0] = new Date().toUTCString()
+      + ' ' + name + ' ' + args[0];
+  }
+  return args;
+}
+
+/**
+ * Invokes `console.error()` with the specified arguments.
+ */
+
+function log() {
+  return stream.write(util.format.apply(this, arguments) + '\n');
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+
+function save(namespaces) {
+  if (null == namespaces) {
+    // If you set a process.env field to null or undefined, it gets cast to the
+    // string 'null' or 'undefined'. Just delete instead.
+    delete process.env.DEBUG;
+  } else {
+    process.env.DEBUG = namespaces;
+  }
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+  return process.env.DEBUG;
+}
+
+/**
+ * Copied from `node/src/node.js`.
+ *
+ * XXX: It's lame that node doesn't expose this API out-of-the-box. It also
+ * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
+ */
+
+function createWritableStdioStream (fd) {
+  var stream;
+  var tty_wrap = process.binding('tty_wrap');
+
+  // Note stream._type is used for test-module-load-list.js
+
+  switch (tty_wrap.guessHandleType(fd)) {
+    case 'TTY':
+      stream = new tty.WriteStream(fd);
+      stream._type = 'tty';
+
+      // Hack to have stream not keep the event loop alive.
+      // See https://github.com/joyent/node/issues/1726
+      if (stream._handle && stream._handle.unref) {
+        stream._handle.unref();
+      }
+      break;
+
+    case 'FILE':
+      var fs = require('fs');
+      stream = new fs.SyncWriteStream(fd, { autoClose: false });
+      stream._type = 'fs';
+      break;
+
+    case 'PIPE':
+    case 'TCP':
+      var net = require('net');
+      stream = new net.Socket({
+        fd: fd,
+        readable: false,
+        writable: true
+      });
+
+      // FIXME Should probably have an option in net.Socket to create a
+      // stream from an existing fd which is writable only. But for now
+      // we'll just add this hack and set the `readable` member to false.
+      // Test: ./node test/fixtures/echo.js < /etc/passwd
+      stream.readable = false;
+      stream.read = null;
+      stream._type = 'pipe';
+
+      // FIXME Hack to have stream not keep the event loop alive.
+      // See https://github.com/joyent/node/issues/1726
+      if (stream._handle && stream._handle.unref) {
+        stream._handle.unref();
+      }
+      break;
+
+    default:
+      // Probably an error on in uv_guess_handle()
+      throw new Error('Implement me. Unknown stream file type!');
+  }
+
+  // For supporting legacy API we put the FD here.
+  stream.fd = fd;
+
+  stream._isStdio = true;
+
+  return stream;
+}
+
+/**
+ * Enable namespaces listed in `process.env.DEBUG` initially.
+ */
+
+exports.enable(load());
+
+}).call(this,require('_process'))
+},{"./debug":173,"_process":147,"fs":137,"net":137,"tty":161,"util":163}],175:[function(require,module,exports){
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} options
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options){
+  options = options || {};
+  if ('string' == typeof val) return parse(val);
+  return options.long
+    ? long(val)
+    : short(val);
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  var match = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);
+  if (!match) return;
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'y':
+      return n * y;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 's':
+      return n * s;
+    case 'ms':
+      return n;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function short(ms) {
+  if (ms >= d) return Math.round(ms / d) + 'd';
+  if (ms >= h) return Math.round(ms / h) + 'h';
+  if (ms >= m) return Math.round(ms / m) + 'm';
+  if (ms >= s) return Math.round(ms / s) + 's';
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function long(ms) {
+  return plural(ms, d, 'day')
+    || plural(ms, h, 'hour')
+    || plural(ms, m, 'minute')
+    || plural(ms, s, 'second')
+    || ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, n, name) {
+  if (ms < n) return;
+  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
+  return Math.ceil(ms / n) + ' ' + name + 's';
+}
+
+},{}],176:[function(require,module,exports){
+'use strict';
+var repeating = require('repeating');
+
+// detect either spaces or tabs but not both to properly handle tabs
+// for indentation and spaces for alignment
+var INDENT_RE = /^(?:( )+|\t+)/;
+
+function getMostUsed(indents) {
+	var result = 0;
+	var maxUsed = 0;
+	var maxWeight = 0;
+
+	for (var n in indents) {
+		var indent = indents[n];
+		var u = indent[0];
+		var w = indent[1];
+
+		if (u > maxUsed || u === maxUsed && w > maxWeight) {
+			maxUsed = u;
+			maxWeight = w;
+			result = +n;
+		}
+	}
+
+	return result;
+}
+
+module.exports = function (str) {
+	if (typeof str !== 'string') {
+		throw new TypeError('Expected a string');
+	}
+
+	// used to see if tabs or spaces are the most used
+	var tabs = 0;
+	var spaces = 0;
+
+	// remember the size of previous line's indentation
+	var prev = 0;
+
+	// remember how many indents/unindents as occurred for a given size
+	// and how much lines follow a given indentation
+	//
+	// indents = {
+	//    3: [1, 0],
+	//    4: [1, 5],
+	//    5: [1, 0],
+	//   12: [1, 0],
+	// }
+	var indents = {};
+
+	// pointer to the array of last used indent
+	var current;
+
+	// whether the last action was an indent (opposed to an unindent)
+	var isIndent;
+
+	str.split(/\n/g).forEach(function (line) {
+		if (!line) {
+			// ignore empty lines
+			return;
+		}
+
+		var indent;
+		var matches = line.match(INDENT_RE);
+
+		if (!matches) {
+			indent = 0;
+		} else {
+			indent = matches[0].length;
+
+			if (matches[1]) {
+				spaces++;
+			} else {
+				tabs++;
+			}
+		}
+
+		var diff = indent - prev;
+		prev = indent;
+
+		if (diff) {
+			// an indent or unindent has been detected
+
+			isIndent = diff > 0;
+
+			current = indents[isIndent ? diff : -diff];
+
+			if (current) {
+				current[0]++;
+			} else {
+				current = indents[diff] = [1, 0];
+			}
+		} else if (current) {
+			// if the last action was an indent, increment the weight
+			current[1] += +isIndent;
+		}
+	});
+
+	var amount = getMostUsed(indents);
+
+	var type;
+	var actual;
+	if (!amount) {
+		type = null;
+		actual = '';
+	} else if (spaces >= tabs) {
+		type = 'space';
+		actual = repeating(' ', amount);
+	} else {
+		type = 'tab';
+		actual = repeating('\t', amount);
+	}
+
+	return {
+		amount: amount,
+		type: type,
+		indent: actual
+	};
+};
+
+},{"repeating":321}],177:[function(require,module,exports){
+/*
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true, define:true*/
+(function (root, factory) {
+    'use strict';
+
+    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
+    // and plain browser loading,
+    if (typeof define === 'function' && define.amd) {
+        define(['exports'], factory);
+    } else if (typeof exports !== 'undefined') {
+        factory(exports);
+    } else {
+        factory((root.estraverse = {}));
+    }
+}(this, function clone(exports) {
+    'use strict';
+
+    var Syntax,
+        isArray,
+        VisitorOption,
+        VisitorKeys,
+        objectCreate,
+        objectKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
+
+    function ignoreJSHintError() { }
+
+    isArray = Array.isArray;
+    if (!isArray) {
+        isArray = function isArray(array) {
+            return Object.prototype.toString.call(array) === '[object Array]';
+        };
+    }
+
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
+
+    function shallowCopy(obj) {
+        var ret = {}, key;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                ret[key] = obj[key];
+            }
+        }
+        return ret;
+    }
+    ignoreJSHintError(shallowCopy);
+
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
+
+    function upperBound(array, func) {
+        var diff, len, i, current;
+
+        len = array.length;
+        i = 0;
+
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
+
+    function lowerBound(array, func) {
+        var diff, len, i, current;
+
+        len = array.length;
+        i = 0;
+
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                i = current + 1;
+                len -= diff + 1;
+            } else {
+                len = diff;
+            }
+        }
+        return i;
+    }
+    ignoreJSHintError(lowerBound);
+
+    objectCreate = Object.create || (function () {
+        function F() { }
+
+        return function (o) {
+            F.prototype = o;
+            return new F();
+        };
+    })();
+
+    objectKeys = Object.keys || function (o) {
+        var keys = [], key;
+        for (key in o) {
+            keys.push(key);
+        }
+        return keys;
+    };
+
+    function extend(to, from) {
+        objectKeys(from).forEach(function (key) {
+            to[key] = from[key];
+        });
+        return to;
+    }
+
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportBatchSpecifier: 'ExportBatchSpecifier',
+        ExportDeclaration: 'ExportDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
+
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'defaults', 'rest', 'body'],
+        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'body', 'superClass'],
+        ClassExpression: ['id', 'body', 'superClass'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportBatchSpecifier: [],
+        ExportDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['id', 'name'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'defaults', 'rest', 'body'],
+        FunctionExpression: ['id', 'params', 'defaults', 'rest', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['id'],
+        ImportNamespaceSpecifier: ['id'],
+        ImportSpecifier: ['id', 'name'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handlers', 'handler', 'guardedHandlers', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
+
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
+
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
+
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
+
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
+
+    Reference.prototype.remove = function remove() {
+        if (isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
+
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
+
+    function Controller() { }
+
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
+
+        function addToPath(result, path) {
+            if (isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
+
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
+
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
+
+    // API:
+    // return type of current node
+    Controller.prototype.type = function () {
+        var node = this.current();
+        return node.type || this.__current.wrap;
+    };
+
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
+
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
+
+        return result;
+    };
+
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
+
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
+
+        result = undefined;
+
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
+
+        return result;
+    };
+
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
+
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
+
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
+
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
+
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = visitor.fallback === 'iteration';
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = extend(objectCreate(this.__keys), visitor.keys);
+        }
+    };
+
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
+
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
+
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
+
+        this.__initialize(root, visitor);
+
+        sentinel = {};
+
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
+
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
+
+        while (worklist.length) {
+            element = worklist.pop();
+
+            if (element === sentinel) {
+                element = leavelist.pop();
+
+                ret = this.__execute(visitor.leave, element);
+
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
+
+            if (element.node) {
+
+                ret = this.__execute(visitor.enter, element);
+
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+
+                worklist.push(sentinel);
+                leavelist.push(element);
+
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
+
+                node = element.node;
+                nodeType = element.wrap || node.type;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = objectKeys(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
+
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
+
+                    if (isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
+
+    Controller.prototype.replace = function replace(root, visitor) {
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
+
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
+
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
+
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
+
+        this.__initialize(root, visitor);
+
+        sentinel = {};
+
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
+
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
+
+        while (worklist.length) {
+            element = worklist.pop();
+
+            if (element === sentinel) {
+                element = leavelist.pop();
+
+                target = this.__execute(visitor.leave, element);
+
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
+
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
+
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
+
+            target = this.__execute(visitor.enter, element);
+
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
+
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
+
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
+
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
+
+            worklist.push(sentinel);
+            leavelist.push(element);
+
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
+
+            nodeType = element.wrap || node.type;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = objectKeys(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
+
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
+
+                if (isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
+
+        return outer.root;
+    };
+
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
+
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
+
+    function extendCommentRange(comment, tokens) {
+        var target;
+
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
+
+        comment.extendedRange = [comment.range[0], comment.range[1]];
+
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
+
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
+
+        return comment;
+    }
+
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
+
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
+
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
+
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
+
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
+
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
+
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
+
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
+
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
+
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
+
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
+
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
+
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
+
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
+
+        return tree;
+    }
+
+    exports.version = '1.8.1-dev';
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+    exports.cloneEnvironment = function () { return clone({}); };
+
+    return exports;
+}));
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{}],178:[function(require,module,exports){
+/*
+  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function () {
+    'use strict';
+
+    function isExpression(node) {
+        if (node == null) { return false; }
+        switch (node.type) {
+            case 'ArrayExpression':
+            case 'AssignmentExpression':
+            case 'BinaryExpression':
+            case 'CallExpression':
+            case 'ConditionalExpression':
+            case 'FunctionExpression':
+            case 'Identifier':
+            case 'Literal':
+            case 'LogicalExpression':
+            case 'MemberExpression':
+            case 'NewExpression':
+            case 'ObjectExpression':
+            case 'SequenceExpression':
+            case 'ThisExpression':
+            case 'UnaryExpression':
+            case 'UpdateExpression':
+                return true;
+        }
+        return false;
+    }
+
+    function isIterationStatement(node) {
+        if (node == null) { return false; }
+        switch (node.type) {
+            case 'DoWhileStatement':
+            case 'ForInStatement':
+            case 'ForStatement':
+            case 'WhileStatement':
+                return true;
+        }
+        return false;
+    }
+
+    function isStatement(node) {
+        if (node == null) { return false; }
+        switch (node.type) {
+            case 'BlockStatement':
+            case 'BreakStatement':
+            case 'ContinueStatement':
+            case 'DebuggerStatement':
+            case 'DoWhileStatement':
+            case 'EmptyStatement':
+            case 'ExpressionStatement':
+            case 'ForInStatement':
+            case 'ForStatement':
+            case 'IfStatement':
+            case 'LabeledStatement':
+            case 'ReturnStatement':
+            case 'SwitchStatement':
+            case 'ThrowStatement':
+            case 'TryStatement':
+            case 'VariableDeclaration':
+            case 'WhileStatement':
+            case 'WithStatement':
+                return true;
+        }
+        return false;
+    }
+
+    function isSourceElement(node) {
+      return isStatement(node) || node != null && node.type === 'FunctionDeclaration';
+    }
+
+    function trailingStatement(node) {
+        switch (node.type) {
+        case 'IfStatement':
+            if (node.alternate != null) {
+                return node.alternate;
+            }
+            return node.consequent;
+
+        case 'LabeledStatement':
+        case 'ForStatement':
+        case 'ForInStatement':
+        case 'WhileStatement':
+        case 'WithStatement':
+            return node.body;
+        }
+        return null;
+    }
+
+    function isProblematicIfStatement(node) {
+        var current;
+
+        if (node.type !== 'IfStatement') {
+            return false;
+        }
+        if (node.alternate == null) {
+            return false;
+        }
+        current = node.consequent;
+        do {
+            if (current.type === 'IfStatement') {
+                if (current.alternate == null)  {
+                    return true;
+                }
+            }
+            current = trailingStatement(current);
+        } while (current);
+
+        return false;
+    }
+
+    module.exports = {
+        isExpression: isExpression,
+        isStatement: isStatement,
+        isIterationStatement: isIterationStatement,
+        isSourceElement: isSourceElement,
+        isProblematicIfStatement: isProblematicIfStatement,
+
+        trailingStatement: trailingStatement
+    };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{}],179:[function(require,module,exports){
+/*
+  Copyright (C) 2013-2014 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2014 Ivan Nikulin <ifaaan@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function () {
+    'use strict';
+
+    var Regex, NON_ASCII_WHITESPACES;
+
+    // See `tools/generate-identifier-regex.js`.
+    Regex = {
+        NonAsciiIdentifierStart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]'),
+        NonAsciiIdentifierPart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0\u08A2-\u08AC\u08E4-\u08FE\u0900-\u0963\u0966-\u096F\u0971-\u0977\u0979-\u097F\u0981-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C82\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D02\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191C\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1D00-\u1DE6\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA697\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7B\uAA80-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE26\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]')
+    };
+
+    function isDecimalDigit(ch) {
+        return (ch >= 48 && ch <= 57);   // 0..9
+    }
+
+    function isHexDigit(ch) {
+        return isDecimalDigit(ch) ||    // 0..9
+            (97 <= ch && ch <= 102) ||  // a..f
+            (65 <= ch && ch <= 70);     // A..F
+    }
+
+    function isOctalDigit(ch) {
+        return (ch >= 48 && ch <= 55);   // 0..7
+    }
+
+    // 7.2 White Space
+
+    NON_ASCII_WHITESPACES = [
+        0x1680, 0x180E,
+        0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A,
+        0x202F, 0x205F,
+        0x3000,
+        0xFEFF
+    ];
+
+    function isWhiteSpace(ch) {
+        return (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
+            (ch >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0);
+    }
+
+    // 7.3 Line Terminators
+
+    function isLineTerminator(ch) {
+        return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029);
+    }
+
+    // 7.6 Identifier Names and Identifiers
+
+    function isIdentifierStart(ch) {
+        return (ch >= 97 && ch <= 122) ||     // a..z
+            (ch >= 65 && ch <= 90) ||         // A..Z
+            (ch === 36) || (ch === 95) ||     // $ (dollar) and _ (underscore)
+            (ch === 92) ||                    // \ (backslash)
+            ((ch >= 0x80) && Regex.NonAsciiIdentifierStart.test(String.fromCharCode(ch)));
+    }
+
+    function isIdentifierPart(ch) {
+        return (ch >= 97 && ch <= 122) ||     // a..z
+            (ch >= 65 && ch <= 90) ||         // A..Z
+            (ch >= 48 && ch <= 57) ||         // 0..9
+            (ch === 36) || (ch === 95) ||     // $ (dollar) and _ (underscore)
+            (ch === 92) ||                    // \ (backslash)
+            ((ch >= 0x80) && Regex.NonAsciiIdentifierPart.test(String.fromCharCode(ch)));
+    }
+
+    module.exports = {
+        isDecimalDigit: isDecimalDigit,
+        isHexDigit: isHexDigit,
+        isOctalDigit: isOctalDigit,
+        isWhiteSpace: isWhiteSpace,
+        isLineTerminator: isLineTerminator,
+        isIdentifierStart: isIdentifierStart,
+        isIdentifierPart: isIdentifierPart
+    };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{}],180:[function(require,module,exports){
+/*
+  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function () {
+    'use strict';
+
+    var code = require('./code');
+
+    function isStrictModeReservedWordES6(id) {
+        switch (id) {
+        case 'implements':
+        case 'interface':
+        case 'package':
+        case 'private':
+        case 'protected':
+        case 'public':
+        case 'static':
+        case 'let':
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    function isKeywordES5(id, strict) {
+        // yield should not be treated as keyword under non-strict mode.
+        if (!strict && id === 'yield') {
+            return false;
+        }
+        return isKeywordES6(id, strict);
+    }
+
+    function isKeywordES6(id, strict) {
+        if (strict && isStrictModeReservedWordES6(id)) {
+            return true;
+        }
+
+        switch (id.length) {
+        case 2:
+            return (id === 'if') || (id === 'in') || (id === 'do');
+        case 3:
+            return (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
+        case 4:
+            return (id === 'this') || (id === 'else') || (id === 'case') ||
+                (id === 'void') || (id === 'with') || (id === 'enum');
+        case 5:
+            return (id === 'while') || (id === 'break') || (id === 'catch') ||
+                (id === 'throw') || (id === 'const') || (id === 'yield') ||
+                (id === 'class') || (id === 'super');
+        case 6:
+            return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
+                (id === 'switch') || (id === 'export') || (id === 'import');
+        case 7:
+            return (id === 'default') || (id === 'finally') || (id === 'extends');
+        case 8:
+            return (id === 'function') || (id === 'continue') || (id === 'debugger');
+        case 10:
+            return (id === 'instanceof');
+        default:
+            return false;
+        }
+    }
+
+    function isReservedWordES5(id, strict) {
+        return id === 'null' || id === 'true' || id === 'false' || isKeywordES5(id, strict);
+    }
+
+    function isReservedWordES6(id, strict) {
+        return id === 'null' || id === 'true' || id === 'false' || isKeywordES6(id, strict);
+    }
+
+    function isRestrictedWord(id) {
+        return id === 'eval' || id === 'arguments';
+    }
+
+    function isIdentifierName(id) {
+        var i, iz, ch;
+
+        if (id.length === 0) {
+            return false;
+        }
+
+        ch = id.charCodeAt(0);
+        if (!code.isIdentifierStart(ch) || ch === 92) {  // \ (backslash)
+            return false;
+        }
+
+        for (i = 1, iz = id.length; i < iz; ++i) {
+            ch = id.charCodeAt(i);
+            if (!code.isIdentifierPart(ch) || ch === 92) {  // \ (backslash)
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function isIdentifierES5(id, strict) {
+        return isIdentifierName(id) && !isReservedWordES5(id, strict);
+    }
+
+    function isIdentifierES6(id, strict) {
+        return isIdentifierName(id) && !isReservedWordES6(id, strict);
+    }
+
+    module.exports = {
+        isKeywordES5: isKeywordES5,
+        isKeywordES6: isKeywordES6,
+        isReservedWordES5: isReservedWordES5,
+        isReservedWordES6: isReservedWordES6,
+        isRestrictedWord: isRestrictedWord,
+        isIdentifierName: isIdentifierName,
+        isIdentifierES5: isIdentifierES5,
+        isIdentifierES6: isIdentifierES6
+    };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{"./code":179}],181:[function(require,module,exports){
+/*
+  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+(function () {
+    'use strict';
+
+    exports.ast = require('./ast');
+    exports.code = require('./code');
+    exports.keyword = require('./keyword');
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+},{"./ast":178,"./code":179,"./keyword":180}],182:[function(require,module,exports){
+module.exports={
+	"builtin": {
+		"Array": false,
+		"ArrayBuffer": false,
+		"Boolean": false,
+		"constructor": false,
+		"Date": false,
+		"decodeURI": false,
+		"decodeURIComponent": false,
+		"encodeURI": false,
+		"encodeURIComponent": false,
+		"Error": false,
+		"eval": false,
+		"EvalError": false,
+		"Float32Array": false,
+		"Float64Array": false,
+		"Function": false,
+		"hasOwnProperty": false,
+		"Infinity": false,
+		"Int16Array": false,
+		"Int32Array": false,
+		"Int8Array": false,
+		"isFinite": false,
+		"isNaN": false,
+		"isPrototypeOf": false,
+		"JSON": false,
+		"Map": false,
+		"Math": false,
+		"NaN": false,
+		"Number": false,
+		"Object": false,
+		"parseFloat": false,
+		"parseInt": false,
+		"Promise": false,
+		"propertyIsEnumerable": false,
+		"Proxy": false,
+		"RangeError": false,
+		"ReferenceError": false,
+		"Reflect": false,
+		"RegExp": false,
+		"Set": false,
+		"String": false,
+		"Symbol": false,
+		"SyntaxError": false,
+		"System": false,
+		"toLocaleString": false,
+		"toString": false,
+		"TypeError": false,
+		"Uint16Array": false,
+		"Uint32Array": false,
+		"Uint8Array": false,
+		"Uint8ClampedArray": false,
+		"undefined": false,
+		"URIError": false,
+		"valueOf": false,
+		"WeakMap": false,
+		"WeakSet": false
+	},
+	"nonstandard": {
+		"escape": false,
+		"unescape": false
+	},
+	"browser": {
+		"addEventListener": false,
+		"alert": false,
+		"applicationCache": false,
+		"atob": false,
+		"Audio": false,
+		"AudioProcessingEvent": false,
+		"BeforeUnloadEvent": false,
+		"Blob": false,
+		"blur": false,
+		"btoa": false,
+		"cancelAnimationFrame": false,
+		"CanvasGradient": false,
+		"CanvasPattern": false,
+		"CanvasRenderingContext2D": false,
+		"clearInterval": false,
+		"clearTimeout": false,
+		"close": false,
+		"closed": false,
+		"CloseEvent": false,
+		"Comment": false,
+		"CompositionEvent": false,
+		"confirm": false,
+		"console": false,
+		"crypto": false,
+		"CSS": false,
+		"CustomEvent": false,
+		"DataView": false,
+		"Debug": false,
+		"defaultStatus": false,
+		"devicePixelRatio": false,
+		"dispatchEvent": false,
+		"document": false,
+		"Document": false,
+		"DocumentFragment": false,
+		"DOMParser": false,
+		"DragEvent": false,
+		"Element": false,
+		"ElementTimeControl": false,
+		"ErrorEvent": false,
+		"event": false,
+		"Event": false,
+		"FileReader": false,
+		"find": false,
+		"focus": false,
+		"FocusEvent": false,
+		"FormData": false,
+		"frameElement": false,
+		"frames": false,
+		"GamepadEvent": false,
+		"getComputedStyle": false,
+		"getSelection": false,
+		"HashChangeEvent": false,
+		"history": false,
+		"HTMLAnchorElement": false,
+		"HTMLBaseElement": false,
+		"HTMLBlockquoteElement": false,
+		"HTMLBodyElement": false,
+		"HTMLBRElement": false,
+		"HTMLButtonElement": false,
+		"HTMLCanvasElement": false,
+		"HTMLDirectoryElement": false,
+		"HTMLDivElement": false,
+		"HTMLDListElement": false,
+		"HTMLElement": false,
+		"HTMLFieldSetElement": false,
+		"HTMLFontElement": false,
+		"HTMLFormElement": false,
+		"HTMLFrameElement": false,
+		"HTMLFrameSetElement": false,
+		"HTMLHeadElement": false,
+		"HTMLHeadingElement": false,
+		"HTMLHRElement": false,
+		"HTMLHtmlElement": false,
+		"HTMLIFrameElement": false,
+		"HTMLImageElement": false,
+		"HTMLInputElement": false,
+		"HTMLIsIndexElement": false,
+		"HTMLLabelElement": false,
+		"HTMLLayerElement": false,
+		"HTMLLegendElement": false,
+		"HTMLLIElement": false,
+		"HTMLLinkElement": false,
+		"HTMLMapElement": false,
+		"HTMLMenuElement": false,
+		"HTMLMetaElement": false,
+		"HTMLModElement": false,
+		"HTMLObjectElement": false,
+		"HTMLOListElement": false,
+		"HTMLOptGroupElement": false,
+		"HTMLOptionElement": false,
+		"HTMLParagraphElement": false,
+		"HTMLParamElement": false,
+		"HTMLPreElement": false,
+		"HTMLQuoteElement": false,
+		"HTMLScriptElement": false,
+		"HTMLSelectElement": false,
+		"HTMLStyleElement": false,
+		"HTMLTableCaptionElement": false,
+		"HTMLTableCellElement": false,
+		"HTMLTableColElement": false,
+		"HTMLTableElement": false,
+		"HTMLTableRowElement": false,
+		"HTMLTableSectionElement": false,
+		"HTMLTextAreaElement": false,
+		"HTMLTitleElement": false,
+		"HTMLUListElement": false,
+		"HTMLVideoElement": false,
+		"IDBCursor": false,
+		"IDBCursorWithValue": false,
+		"IDBDatabase": false,
+		"IDBEnvironment": false,
+		"IDBFactory": false,
+		"IDBIndex": false,
+		"IDBKeyRange": false,
+		"IDBObjectStore": false,
+		"IDBOpenDBRequest": false,
+		"IDBRequest": false,
+		"IDBTransaction": false,
+		"IDBVersionChangeEvent": false,
+		"Image": false,
+		"indexedDB": false,
+		"innerHeight": false,
+		"innerWidth": false,
+		"InputEvent": false,
+		"Intl": false,
+		"KeyboardEvent": false,
+		"length": false,
+		"localStorage": false,
+		"location": false,
+		"matchMedia": false,
+		"MessageChannel": false,
+		"MessageEvent": false,
+		"MessagePort": false,
+		"MouseEvent": false,
+		"moveBy": false,
+		"moveTo": false,
+		"MutationObserver": false,
+		"name": false,
+		"navigator": false,
+		"Node": false,
+		"NodeFilter": false,
+		"NodeList": false,
+		"Notification": false,
+		"OfflineAudioCompletionEvent": false,
+		"onbeforeunload": true,
+		"onblur": true,
+		"onerror": true,
+		"onfocus": true,
+		"onload": true,
+		"onresize": true,
+		"onunload": true,
+		"open": false,
+		"openDatabase": false,
+		"opener": false,
+		"opera": false,
+		"Option": false,
+		"outerHeight": false,
+		"outerWidth": false,
+		"PageTransitionEvent": false,
+		"pageXOffset": false,
+		"pageYOffset": false,
+		"parent": false,
+		"PopStateEvent": false,
+		"postMessage": false,
+		"print": false,
+		"ProgressEvent": false,
+		"prompt": false,
+		"Range": false,
+		"removeEventListener": false,
+		"requestAnimationFrame": false,
+		"resizeBy": false,
+		"resizeTo": false,
+		"screen": false,
+		"screenX": false,
+		"screenY": false,
+		"scroll": false,
+		"scrollbars": false,
+		"scrollBy": false,
+		"scrollTo": false,
+		"scrollX": false,
+		"scrollY": false,
+		"self": false,
+		"sessionStorage": false,
+		"setInterval": false,
+		"setTimeout": false,
+		"SharedWorker": false,
+		"showModalDialog": false,
+		"status": false,
+		"stop": false,
+		"StorageEvent": false,
+		"SVGAElement": false,
+		"SVGAltGlyphDefElement": false,
+		"SVGAltGlyphElement": false,
+		"SVGAltGlyphItemElement": false,
+		"SVGAngle": false,
+		"SVGAnimateColorElement": false,
+		"SVGAnimatedAngle": false,
+		"SVGAnimatedBoolean": false,
+		"SVGAnimatedEnumeration": false,
+		"SVGAnimatedInteger": false,
+		"SVGAnimatedLength": false,
+		"SVGAnimatedLengthList": false,
+		"SVGAnimatedNumber": false,
+		"SVGAnimatedNumberList": false,
+		"SVGAnimatedPathData": false,
+		"SVGAnimatedPoints": false,
+		"SVGAnimatedPreserveAspectRatio": false,
+		"SVGAnimatedRect": false,
+		"SVGAnimatedString": false,
+		"SVGAnimatedTransformList": false,
+		"SVGAnimateElement": false,
+		"SVGAnimateMotionElement": false,
+		"SVGAnimateTransformElement": false,
+		"SVGAnimationElement": false,
+		"SVGCircleElement": false,
+		"SVGClipPathElement": false,
+		"SVGColor": false,
+		"SVGColorProfileElement": false,
+		"SVGColorProfileRule": false,
+		"SVGComponentTransferFunctionElement": false,
+		"SVGCSSRule": false,
+		"SVGCursorElement": false,
+		"SVGDefsElement": false,
+		"SVGDescElement": false,
+		"SVGDocument": false,
+		"SVGElement": false,
+		"SVGElementInstance": false,
+		"SVGElementInstanceList": false,
+		"SVGEllipseElement": false,
+		"SVGEvent": false,
+		"SVGExternalResourcesRequired": false,
+		"SVGFEBlendElement": false,
+		"SVGFEColorMatrixElement": false,
+		"SVGFEComponentTransferElement": false,
+		"SVGFECompositeElement": false,
+		"SVGFEConvolveMatrixElement": false,
+		"SVGFEDiffuseLightingElement": false,
+		"SVGFEDisplacementMapElement": false,
+		"SVGFEDistantLightElement": false,
+		"SVGFEFloodElement": false,
+		"SVGFEFuncAElement": false,
+		"SVGFEFuncBElement": false,
+		"SVGFEFuncGElement": false,
+		"SVGFEFuncRElement": false,
+		"SVGFEGaussianBlurElement": false,
+		"SVGFEImageElement": false,
+		"SVGFEMergeElement": false,
+		"SVGFEMergeNodeElement": false,
+		"SVGFEMorphologyElement": false,
+		"SVGFEOffsetElement": false,
+		"SVGFEPointLightElement": false,
+		"SVGFESpecularLightingElement": false,
+		"SVGFESpotLightElement": false,
+		"SVGFETileElement": false,
+		"SVGFETurbulenceElement": false,
+		"SVGFilterElement": false,
+		"SVGFilterPrimitiveStandardAttributes": false,
+		"SVGFitToViewBox": false,
+		"SVGFontElement": false,
+		"SVGFontFaceElement": false,
+		"SVGFontFaceFormatElement": false,
+		"SVGFontFaceNameElement": false,
+		"SVGFontFaceSrcElement": false,
+		"SVGFontFaceUriElement": false,
+		"SVGForeignObjectElement": false,
+		"SVGGElement": false,
+		"SVGGlyphElement": false,
+		"SVGGlyphRefElement": false,
+		"SVGGradientElement": false,
+		"SVGHKernElement": false,
+		"SVGICCColor": false,
+		"SVGImageElement": false,
+		"SVGLangSpace": false,
+		"SVGLength": false,
+		"SVGLengthList": false,
+		"SVGLinearGradientElement": false,
+		"SVGLineElement": false,
+		"SVGLocatable": false,
+		"SVGMarkerElement": false,
+		"SVGMaskElement": false,
+		"SVGMatrix": false,
+		"SVGMetadataElement": false,
+		"SVGMissingGlyphElement": false,
+		"SVGMPathElement": false,
+		"SVGNumber": false,
+		"SVGNumberList": false,
+		"SVGPaint": false,
+		"SVGPathElement": false,
+		"SVGPathSeg": false,
+		"SVGPathSegArcAbs": false,
+		"SVGPathSegArcRel": false,
+		"SVGPathSegClosePath": false,
+		"SVGPathSegCurvetoCubicAbs": false,
+		"SVGPathSegCurvetoCubicRel": false,
+		"SVGPathSegCurvetoCubicSmoothAbs": false,
+		"SVGPathSegCurvetoCubicSmoothRel": false,
+		"SVGPathSegCurvetoQuadraticAbs": false,
+		"SVGPathSegCurvetoQuadraticRel": false,
+		"SVGPathSegCurvetoQuadraticSmoothAbs": false,
+		"SVGPathSegCurvetoQuadraticSmoothRel": false,
+		"SVGPathSegLinetoAbs": false,
+		"SVGPathSegLinetoHorizontalAbs": false,
+		"SVGPathSegLinetoHorizontalRel": false,
+		"SVGPathSegLinetoRel": false,
+		"SVGPathSegLinetoVerticalAbs": false,
+		"SVGPathSegLinetoVerticalRel": false,
+		"SVGPathSegList": false,
+		"SVGPathSegMovetoAbs": false,
+		"SVGPathSegMovetoRel": false,
+		"SVGPatternElement": false,
+		"SVGPoint": false,
+		"SVGPointList": false,
+		"SVGPolygonElement": false,
+		"SVGPolylineElement": false,
+		"SVGPreserveAspectRatio": false,
+		"SVGRadialGradientElement": false,
+		"SVGRect": false,
+		"SVGRectElement": false,
+		"SVGRenderingIntent": false,
+		"SVGScriptElement": false,
+		"SVGSetElement": false,
+		"SVGStopElement": false,
+		"SVGStringList": false,
+		"SVGStylable": false,
+		"SVGStyleElement": false,
+		"SVGSVGElement": false,
+		"SVGSwitchElement": false,
+		"SVGSymbolElement": false,
+		"SVGTests": false,
+		"SVGTextContentElement": false,
+		"SVGTextElement": false,
+		"SVGTextPathElement": false,
+		"SVGTextPositioningElement": false,
+		"SVGTitleElement": false,
+		"SVGTransform": false,
+		"SVGTransformable": false,
+		"SVGTransformList": false,
+		"SVGTRefElement": false,
+		"SVGTSpanElement": false,
+		"SVGUnitTypes": false,
+		"SVGURIReference": false,
+		"SVGUseElement": false,
+		"SVGViewElement": false,
+		"SVGViewSpec": false,
+		"SVGVKernElement": false,
+		"SVGZoomAndPan": false,
+		"Text": false,
+		"TextDecoder": false,
+		"TextEncoder": false,
+		"TimeEvent": false,
+		"top": false,
+		"TouchEvent": false,
+		"UIEvent": false,
+		"URL": false,
+		"WebGLActiveInfo": false,
+		"WebGLBuffer": false,
+		"WebGLContextEvent": false,
+		"WebGLFramebuffer": false,
+		"WebGLProgram": false,
+		"WebGLRenderbuffer": false,
+		"WebGLRenderingContext": false,
+		"WebGLShader": false,
+		"WebGLShaderPrecisionFormat": false,
+		"WebGLTexture": false,
+		"WebGLUniformLocation": false,
+		"WebSocket": false,
+		"WheelEvent": false,
+		"window": false,
+		"Window": false,
+		"Worker": false,
+		"XDomainRequest": false,
+		"XMLHttpRequest": false,
+		"XMLSerializer": false,
+		"XPathEvaluator": false,
+		"XPathException": false,
+		"XPathExpression": false,
+		"XPathNamespace": false,
+		"XPathNSResolver": false,
+		"XPathResult": false
+	},
+	"worker": {
+		"importScripts": true,
+		"postMessage": true,
+		"self": true
+	},
+	"node": {
+		"__dirname": false,
+		"__filename": false,
+		"arguments": false,
+		"Buffer": false,
+		"clearImmediate": false,
+		"clearInterval": false,
+		"clearTimeout": false,
+		"console": false,
+		"DataView": false,
+		"exports": true,
+		"GLOBAL": false,
+		"global": false,
+		"module": false,
+		"process": false,
+		"require": false,
+		"setImmediate": false,
+		"setInterval": false,
+		"setTimeout": false
+	},
+	"amd": {
+		"define": false,
+		"require": false
+	},
+	"mocha": {
+		"after": false,
+		"afterEach": false,
+		"before": false,
+		"beforeEach": false,
+		"context": false,
+		"describe": false,
+		"it": false,
+		"setup": false,
+		"specify": false,
+		"suite": false,
+		"suiteSetup": false,
+		"suiteTeardown": false,
+		"teardown": false,
+		"test": false,
+		"xcontext": false,
+		"xdescribe": false,
+		"xit": false,
+		"xspecify": false
+	},
+	"jasmine": {
+		"afterAll": false,
+		"afterEach": false,
+		"beforeAll": false,
+		"beforeEach": false,
+		"describe": false,
+		"expect": false,
+		"fail": false,
+		"fdescribe": false,
+		"fit": false,
+		"it": false,
+		"jasmine": false,
+		"pending": false,
+		"runs": false,
+		"spyOn": false,
+		"waits": false,
+		"waitsFor": false,
+		"xdescribe": false,
+		"xit": false
+	},
+	"qunit": {
+		"asyncTest": false,
+		"deepEqual": false,
+		"equal": false,
+		"expect": false,
+		"module": false,
+		"notDeepEqual": false,
+		"notEqual": false,
+		"notPropEqual": false,
+		"notStrictEqual": false,
+		"ok": false,
+		"propEqual": false,
+		"QUnit": false,
+		"raises": false,
+		"start": false,
+		"stop": false,
+		"strictEqual": false,
+		"test": false,
+		"throws": false
+	},
+	"phantomjs": {
+		"console": true,
+		"exports": true,
+		"phantom": true,
+		"require": true,
+		"WebPage": true
+	},
+	"couch": {
+		"emit": false,
+		"exports": false,
+		"getRow": false,
+		"log": false,
+		"module": false,
+		"provides": false,
+		"require": false,
+		"respond": false,
+		"send": false,
+		"start": false,
+		"sum": false
+	},
+	"rhino": {
+		"defineClass": false,
+		"deserialize": false,
+		"gc": false,
+		"help": false,
+		"importClass": false,
+		"importPackage": false,
+		"java": false,
+		"load": false,
+		"loadClass": false,
+		"Packages": false,
+		"print": false,
+		"quit": false,
+		"readFile": false,
+		"readUrl": false,
+		"runCommand": false,
+		"seal": false,
+		"serialize": false,
+		"spawn": false,
+		"sync": false,
+		"toint32": false,
+		"version": false
+	},
+	"wsh": {
+		"ActiveXObject": true,
+		"Enumerator": true,
+		"GetObject": true,
+		"ScriptEngine": true,
+		"ScriptEngineBuildVersion": true,
+		"ScriptEngineMajorVersion": true,
+		"ScriptEngineMinorVersion": true,
+		"VBArray": true,
+		"WScript": true,
+		"WSH": true,
+		"XDomainRequest": true
+	},
+	"jquery": {
+		"$": false,
+		"jQuery": false
+	},
+	"yui": {
+		"Y": false,
+		"YUI": false,
+		"YUI_config": false
+	},
+	"shelljs": {
+		"cat": false,
+		"cd": false,
+		"chmod": false,
+		"config": false,
+		"cp": false,
+		"dirs": false,
+		"echo": false,
+		"env": false,
+		"error": false,
+		"exec": false,
+		"exit": false,
+		"find": false,
+		"grep": false,
+		"ls": false,
+		"mkdir": false,
+		"mv": false,
+		"popd": false,
+		"pushd": false,
+		"pwd": false,
+		"rm": false,
+		"sed": false,
+		"target": false,
+		"tempdir": false,
+		"test": false,
+		"which": false
+	},
+	"prototypejs": {
+		"$": false,
+		"$$": false,
+		"$A": false,
+		"$break": false,
+		"$continue": false,
+		"$F": false,
+		"$H": false,
+		"$R": false,
+		"$w": false,
+		"Abstract": false,
+		"Ajax": false,
+		"Autocompleter": false,
+		"Builder": false,
+		"Class": false,
+		"Control": false,
+		"Draggable": false,
+		"Draggables": false,
+		"Droppables": false,
+		"Effect": false,
+		"Element": false,
+		"Enumerable": false,
+		"Event": false,
+		"Field": false,
+		"Form": false,
+		"Hash": false,
+		"Insertion": false,
+		"ObjectRange": false,
+		"PeriodicalExecuter": false,
+		"Position": false,
+		"Prototype": false,
+		"Scriptaculous": false,
+		"Selector": false,
+		"Sortable": false,
+		"SortableObserver": false,
+		"Sound": false,
+		"Template": false,
+		"Toggle": false,
+		"Try": false
+	},
+	"meteor": {
+		"$": false,
+		"_": false,
+		"Accounts": false,
+		"App": false,
+		"Assets": false,
+		"Blaze": false,
+		"check": false,
+		"Cordova": false,
+		"DDP": false,
+		"DDPServer": false,
+		"Deps": false,
+		"EJSON": false,
+		"Email": false,
+		"HTTP": false,
+		"Log": false,
+		"Match": false,
+		"Meteor": false,
+		"Mongo": false,
+		"MongoInternals": false,
+		"Npm": false,
+		"Package": false,
+		"Plugin": false,
+		"process": false,
+		"Random": false,
+		"ReactiveDict": false,
+		"ReactiveVar": false,
+		"Router": false,
+		"Session": false,
+		"share": false,
+		"Spacebars": false,
+		"Template": false,
+		"Tinytest": false,
+		"Tracker": false,
+		"UI": false,
+		"Utils": false,
+		"WebApp": false,
+		"WebAppInternals": false
+	},
+	"mongo": {
+		"_isWindows": false,
+		"_rand": false,
+		"BulkWriteResult": false,
+		"cat": false,
+		"cd": false,
+		"connect": false,
+		"db": false,
+		"getHostName": false,
+		"getMemInfo": false,
+		"hostname": false,
+		"listFiles": false,
+		"load": false,
+		"ls": false,
+		"md5sumFile": false,
+		"mkdir": false,
+		"Mongo": false,
+		"ObjectId": false,
+		"PlanCache": false,
+		"pwd": false,
+		"quit": false,
+		"removeFile": false,
+		"rs": false,
+		"sh": false,
+		"UUID": false,
+		"version": false,
+		"WriteResult": false
+	}
+}
+
+},{}],183:[function(require,module,exports){
+module.exports = require('./globals.json');
+
+},{"./globals.json":182}],184:[function(require,module,exports){
+// https://github.com/paulmillr/es6-shim
+// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isinteger
+var isNaN = require("is-nan");
+var isFinite = require("is-finite");
+module.exports = Number.isInteger || function(val) {
+	return typeof val === "number" &&
+		! isNaN(val) &&
+		isFinite(val) &&
+		parseInt(val, 10) === val;
+};
+
+},{"is-finite":185,"is-nan":186}],185:[function(require,module,exports){
+'use strict';
+module.exports = Number.isFinite || function (val) {
+	// Number.isNaN() => val !== val
+	if (typeof val !== 'number' || val !== val || val === Infinity || val === -Infinity) {
+		return false;
+	}
+
+	return true;
+};
+
+},{}],186:[function(require,module,exports){
+"use strict";
+
+/* https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isnan */
+
+module.exports = function isNaN(value) {
+	return value !== value;
+};
+
+
+},{}],187:[function(require,module,exports){
+// Copyright 2014, 2015 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+// This regex comes from regex.coffee, and is inserted here by generate-index.js
+// (run `npm run build`).
+module.exports = /((['"])(?:(?!\2)[^\\\r\n\u2028\u2029]|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:[^\]\\\r\n\u2028\u2029]|\\.)*\]|[^\/\]\\\r\n\u2028\u2029]|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyu]{1,5}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(-?(?:0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?))|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]{1,6}\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-*\/%&|^]|<{1,2}|>{1,3}|!=?|={1,2})=?|[?:~])|([;,.[\](){}])|(\s+)|(^$|[\s\S])/g
+
+module.exports.matchToToken = function(match) {
+  token = {type: "invalid", value: match[0]}
+       if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4])
+  else if (match[ 5]) token.type = "comment"
+  else if (match[ 6]) token.type = "comment", token.closed = !!match[7]
+  else if (match[ 8]) token.type = "regex"
+  else if (match[ 9]) token.type = "number"
+  else if (match[10]) token.type = "name"
+  else if (match[11]) token.type = "operator"
+  else if (match[12]) token.type = "punctuation"
+  else if (match[13]) token.type = "whitespace"
+  return token
+}
+
+},{}],188:[function(require,module,exports){
+// intentionally commented out as it makes it slower...
+//'use strict';
+
+var arr = [];
+var charCodeCache = [];
+
+module.exports = function (a, b) {
+	if (a === b) {
+		return 0;
+	}
+
+	var aLen = a.length;
+	var bLen = b.length;
+
+	if (aLen === 0) {
+		return bLen;
+	}
+
+	if (bLen === 0) {
+		return aLen;
+	}
+
+	var bCharCode;
+	var ret;
+	var tmp;
+	var tmp2;
+	var i = 0;
+	var j = 0;
+
+	while (i < aLen) {
+		charCodeCache[i] = a.charCodeAt(i);
+		arr[i] = ++i;
+	}
+
+	while (j < bLen) {
+		bCharCode = b.charCodeAt(j);
+		tmp = j++;
+		ret = j;
+
+		for (i = 0; i < aLen; i++) {
+			tmp2 = bCharCode === charCodeCache[i] ? tmp : tmp + 1;
+			tmp = arr[i];
+			ret = arr[i] = tmp > ret ? tmp2 > ret ? ret + 1 : tmp2 : tmp2 > tmp ? tmp + 1 : tmp2;
+		}
+	}
+
+	return ret;
+};
+
+},{}],189:[function(require,module,exports){
+// Copyright 2014, 2015 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var leftPad = require("left-pad")
+
+function get(options, key, defaultValue) {
+  return (key in options ? options[key] : defaultValue)
+}
+
+function lineNumbers(code, options) {
+  var getOption = get.bind(null, options || {})
+  var transform = getOption("transform", Function.prototype)
+  var padding   = getOption("padding", " ")
+  var before    = getOption("before", " ")
+  var after     = getOption("after", " | ")
+  var start     = getOption("start", 1)
+  var isArray   = Array.isArray(code)
+  var lines     = (isArray ? code : code.split("\n"))
+  var end       = start + lines.length - 1
+  var width     = String(end).length
+  var numbered  = lines.map(function(line, index) {
+    var number  = start + index
+    var params  = {before: before, number: number, width: width, after: after,
+                   line: line}
+    transform(params)
+    return params.before + leftPad(params.number, width, padding) +
+           params.after + params.line
+  })
+  return (isArray ? numbered : numbered.join("\n"))
+}
+
+module.exports = lineNumbers
+
+},{"left-pad":190}],190:[function(require,module,exports){
+module.exports = leftpad;
+
+function leftpad (str, len, ch) {
+  str = String(str);
+
+  var i = -1;
+
+  ch || (ch = ' ');
+  len = len - str.length;
+
+
+  while (++i < len) {
+    str = ch + str;
+  }
+
+  return str;
+}
+
+},{}],191:[function(require,module,exports){
+/**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are falsey.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+function compact(array) {
+  var index = -1,
+      length = array ? array.length : 0,
+      resIndex = -1,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (value) {
+      result[++resIndex] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = compact;
+
+},{}],192:[function(require,module,exports){
+var baseFlatten = require('../internal/baseFlatten'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Flattens a nested array. If `isDeep` is `true` the array is recursively
+ * flattened, otherwise it is only flattened a single level.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isDeep] Specify a deep flatten.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2, 3, [4]]]);
+ * // => [1, 2, 3, [4]];
+ *
+ * // using `isDeep`
+ * _.flatten([1, [2, 3, [4]]], true);
+ * // => [1, 2, 3, 4];
+ */
+function flatten(array, isDeep, guard) {
+  var length = array ? array.length : 0;
+  if (guard && isIterateeCall(array, isDeep, guard)) {
+    isDeep = false;
+  }
+  return length ? baseFlatten(array, isDeep) : [];
+}
+
+module.exports = flatten;
+
+},{"../internal/baseFlatten":222,"../internal/isIterateeCall":268}],193:[function(require,module,exports){
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+function last(array) {
+  var length = array ? array.length : 0;
+  return length ? array[length - 1] : undefined;
+}
+
+module.exports = last;
+
+},{}],194:[function(require,module,exports){
+var baseIndexOf = require('../internal/baseIndexOf');
+
+/** Used for native method references. */
+var arrayProto = Array.prototype;
+
+/** Native method references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes all provided values from `array` using `SameValueZero` for equality
+ * comparisons.
+ *
+ * **Notes:**
+ *  - Unlike `_.without`, this method mutates `array`.
+ *  - `SameValueZero` comparisons are like strict equality comparisons, e.g. `===`,
+ *    except that `NaN` matches `NaN`. See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ *    for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {...*} [values] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * _.pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+function pull() {
+  var array = arguments[0];
+  if (!(array && array.length)) {
+    return array;
+  }
+  var index = 0,
+      indexOf = baseIndexOf,
+      length = arguments.length;
+
+  while (++index < length) {
+    var fromIndex = 0,
+        value = arguments[index];
+
+    while ((fromIndex = indexOf(array, value, fromIndex)) > -1) {
+      splice.call(array, fromIndex, 1);
+    }
+  }
+  return array;
+}
+
+module.exports = pull;
+
+},{"../internal/baseIndexOf":227}],195:[function(require,module,exports){
+var baseCallback = require('../internal/baseCallback'),
+    baseUniq = require('../internal/baseUniq'),
+    isIterateeCall = require('../internal/isIterateeCall'),
+    sortedUniq = require('../internal/sortedUniq');
+
+/**
+ * Creates a duplicate-value-free version of an array using `SameValueZero`
+ * for equality comparisons. Providing `true` for `isSorted` performs a faster
+ * search algorithm for sorted arrays. If an iteratee function is provided it
+ * is invoked for each value in the array to generate the criterion by which
+ * uniqueness is computed. The `iteratee` is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
+ *
+ * If a property name is provided for `predicate` the created `_.property`
+ * style callback returns the property value of the given element.
+ *
+ * If a value is also provided for `thisArg` the created `_.matchesProperty`
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created `_.matches` style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @alias unique
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {boolean} [isSorted] Specify the array is sorted.
+ * @param {Function|Object|string} [iteratee] The function invoked per iteration.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array} Returns the new duplicate-value-free array.
+ * @example
+ *
+ * _.uniq([1, 2, 1]);
+ * // => [1, 2]
+ *
+ * // using `isSorted`
+ * _.uniq([1, 1, 2], true);
+ * // => [1, 2]
+ *
+ * // using an iteratee function
+ * _.uniq([1, 2.5, 1.5, 2], function(n) {
+ *   return this.floor(n);
+ * }, Math);
+ * // => [1, 2.5]
+ *
+ * // using the `_.property` callback shorthand
+ * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+function uniq(array, isSorted, iteratee, thisArg) {
+  var length = array ? array.length : 0;
+  if (!length) {
+    return [];
+  }
+  if (isSorted != null && typeof isSorted != 'boolean') {
+    thisArg = iteratee;
+    iteratee = isIterateeCall(array, isSorted, thisArg) ? null : isSorted;
+    isSorted = false;
+  }
+  iteratee = iteratee == null ? iteratee : baseCallback(iteratee, thisArg, 3);
+  return (isSorted)
+    ? sortedUniq(array, iteratee)
+    : baseUniq(array, iteratee);
+}
+
+module.exports = uniq;
+
+},{"../internal/baseCallback":215,"../internal/baseUniq":241,"../internal/isIterateeCall":268,"../internal/sortedUniq":278}],196:[function(require,module,exports){
+module.exports = require('./includes');
+
+},{"./includes":200}],197:[function(require,module,exports){
+module.exports = require('./forEach');
+
+},{"./forEach":198}],198:[function(require,module,exports){
+var arrayEach = require('../internal/arrayEach'),
+    baseEach = require('../internal/baseEach'),
+    bindCallback = require('../internal/bindCallback'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Iterates over elements of `collection` invoking `iteratee` for each element.
+ * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection). Iterator functions may exit iteration early
+ * by explicitly returning `false`.
+ *
+ * **Note:** As with other "Collections" methods, objects with a `length` property
+ * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
+ * may be used for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @alias each
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2]).forEach(function(n) {
+ *   console.log(n);
+ * }).value();
+ * // => logs each value from left to right and returns the array
+ *
+ * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {
+ *   console.log(n, key);
+ * });
+ * // => logs each value-key pair and returns the object (iteration order is not guaranteed)
+ */
+function forEach(collection, iteratee, thisArg) {
+  return (typeof iteratee == 'function' && typeof thisArg == 'undefined' && isArray(collection))
+    ? arrayEach(collection, iteratee)
+    : baseEach(collection, bindCallback(iteratee, thisArg, 3));
+}
+
+module.exports = forEach;
+
+},{"../internal/arrayEach":209,"../internal/baseEach":220,"../internal/bindCallback":243,"../lang/isArray":283}],199:[function(require,module,exports){
+var createAggregator = require('../internal/createAggregator');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` through `iteratee`. The corresponding value
+ * of each key is an array of the elements responsible for generating the key.
+ * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `predicate` the created `_.property`
+ * style callback returns the property value of the given element.
+ *
+ * If a value is also provided for `thisArg` the created `_.matchesProperty`
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created `_.matches` style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+ *  per iteration.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(n) {
+ *   return Math.floor(n);
+ * });
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(n) {
+ *   return this.floor(n);
+ * }, Math);
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * // using the `_.property` callback shorthand
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+var groupBy = createAggregator(function(result, value, key) {
+  if (hasOwnProperty.call(result, key)) {
+    result[key].push(value);
+  } else {
+    result[key] = [value];
+  }
+});
+
+module.exports = groupBy;
+
+},{"../internal/createAggregator":250}],200:[function(require,module,exports){
+var baseIndexOf = require('../internal/baseIndexOf'),
+    isArray = require('../lang/isArray'),
+    isLength = require('../internal/isLength'),
+    isString = require('../lang/isString'),
+    values = require('../object/values');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Checks if `value` is in `collection` using `SameValueZero` for equality
+ * comparisons. If `fromIndex` is negative, it is used as the offset from
+ * the end of `collection`.
+ *
+ * **Note:** `SameValueZero` comparisons are like strict equality comparisons,
+ * e.g. `===`, except that `NaN` matches `NaN`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @alias contains, include
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to search.
+ * @param {*} target The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {boolean} Returns `true` if a matching element is found, else `false`.
+ * @example
+ *
+ * _.includes([1, 2, 3], 1);
+ * // => true
+ *
+ * _.includes([1, 2, 3], 1, 2);
+ * // => false
+ *
+ * _.includes({ 'user': 'fred', 'age': 40 }, 'fred');
+ * // => true
+ *
+ * _.includes('pebbles', 'eb');
+ * // => true
+ */
+function includes(collection, target, fromIndex) {
+  var length = collection ? collection.length : 0;
+  if (!isLength(length)) {
+    collection = values(collection);
+    length = collection.length;
+  }
+  if (!length) {
+    return false;
+  }
+  if (typeof fromIndex == 'number') {
+    fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0);
+  } else {
+    fromIndex = 0;
+  }
+  return (typeof collection == 'string' || !isArray(collection) && isString(collection))
+    ? (fromIndex < length && collection.indexOf(target, fromIndex) > -1)
+    : (baseIndexOf(collection, target, fromIndex) > -1);
+}
+
+module.exports = includes;
+
+},{"../internal/baseIndexOf":227,"../internal/isLength":269,"../lang/isArray":283,"../lang/isString":291,"../object/values":299}],201:[function(require,module,exports){
+var arrayMap = require('../internal/arrayMap'),
+    baseCallback = require('../internal/baseCallback'),
+    baseMap = require('../internal/baseMap'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Creates an array of values by running each element in `collection` through
+ * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three
+ * arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `predicate` the created `_.property`
+ * style callback returns the property value of the given element.
+ *
+ * If a value is also provided for `thisArg` the created `_.matchesProperty`
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created `_.matches` style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * Many lodash methods are guarded to work as interatees for methods like
+ * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+ *
+ * The guarded methods are:
+ * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`, `drop`,
+ * `dropRight`, `fill`, `flatten`, `invert`, `max`, `min`, `parseInt`, `slice`,
+ * `sortBy`, `take`, `takeRight`, `template`, `trim`, `trimLeft`, `trimRight`,
+ * `trunc`, `random`, `range`, `sample`, `uniq`, and `words`
+ *
+ * @static
+ * @memberOf _
+ * @alias collect
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The function invoked
+ *  per iteration.
+ *  create a `_.property` or `_.matches` style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array} Returns the new mapped array.
+ * @example
+ *
+ * function timesThree(n) {
+ *   return n * 3;
+ * }
+ *
+ * _.map([1, 2], timesThree);
+ * // => [3, 6]
+ *
+ * _.map({ 'a': 1, 'b': 2 }, timesThree);
+ * // => [3, 6] (iteration order is not guaranteed)
+ *
+ * var users = [
+ *   { 'user': 'barney' },
+ *   { 'user': 'fred' }
+ * ];
+ *
+ * // using the `_.property` callback shorthand
+ * _.map(users, 'user');
+ * // => ['barney', 'fred']
+ */
+function map(collection, iteratee, thisArg) {
+  var func = isArray(collection) ? arrayMap : baseMap;
+  iteratee = baseCallback(iteratee, thisArg, 3);
+  return func(collection, iteratee);
+}
+
+module.exports = map;
+
+},{"../internal/arrayMap":210,"../internal/baseCallback":215,"../internal/baseMap":232,"../lang/isArray":283}],202:[function(require,module,exports){
+var arrayReduceRight = require('../internal/arrayReduceRight'),
+    baseCallback = require('../internal/baseCallback'),
+    baseEachRight = require('../internal/baseEachRight'),
+    baseReduce = require('../internal/baseReduce'),
+    isArray = require('../lang/isArray');
+
+/**
+ * This method is like `_.reduce` except that it iterates over elements of
+ * `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias foldr
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * var array = [[0, 1], [2, 3], [4, 5]];
+ *
+ * _.reduceRight(array, function(flattened, other) {
+ *   return flattened.concat(other);
+ * }, []);
+ * // => [4, 5, 2, 3, 0, 1]
+ */
+function reduceRight(collection, iteratee, accumulator, thisArg) {
+  var func = isArray(collection) ? arrayReduceRight : baseReduce;
+  return func(collection, baseCallback(iteratee, thisArg, 4), accumulator, arguments.length < 3, baseEachRight);
+}
+
+module.exports = reduceRight;
+
+},{"../internal/arrayReduceRight":211,"../internal/baseCallback":215,"../internal/baseEachRight":221,"../internal/baseReduce":236,"../lang/isArray":283}],203:[function(require,module,exports){
+var arraySome = require('../internal/arraySome'),
+    baseCallback = require('../internal/baseCallback'),
+    baseSome = require('../internal/baseSome'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Checks if `predicate` returns truthy for **any** element of `collection`.
+ * The function returns as soon as it finds a passing value and does not iterate
+ * over the entire collection. The predicate is bound to `thisArg` and invoked
+ * with three arguments; (value, index|key, collection).
+ *
+ * If a property name is provided for `predicate` the created `_.property`
+ * style callback returns the property value of the given element.
+ *
+ * If a value is also provided for `thisArg` the created `_.matchesProperty`
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created `_.matches` style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias any
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked
+ *  per iteration.
+ * @param {*} [thisArg] The `this` binding of `predicate`.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false], Boolean);
+ * // => true
+ *
+ * var users = [
+ *   { 'user': 'barney', 'active': true },
+ *   { 'user': 'fred',   'active': false }
+ * ];
+ *
+ * // using the `_.matches` callback shorthand
+ * _.some(users, { 'user': 'barney', 'active': false });
+ * // => false
+ *
+ * // using the `_.matchesProperty` callback shorthand
+ * _.some(users, 'active', false);
+ * // => true
+ *
+ * // using the `_.property` callback shorthand
+ * _.some(users, 'active');
+ * // => true
+ */
+function some(collection, predicate, thisArg) {
+  var func = isArray(collection) ? arraySome : baseSome;
+  if (typeof predicate != 'function' || typeof thisArg != 'undefined') {
+    predicate = baseCallback(predicate, thisArg, 3);
+  }
+  return func(collection, predicate);
+}
+
+module.exports = some;
+
+},{"../internal/arraySome":212,"../internal/baseCallback":215,"../internal/baseSome":238,"../lang/isArray":283}],204:[function(require,module,exports){
+var baseCallback = require('../internal/baseCallback'),
+    baseEach = require('../internal/baseEach'),
+    baseSortBy = require('../internal/baseSortBy'),
+    compareAscending = require('../internal/compareAscending'),
+    isIterateeCall = require('../internal/isIterateeCall'),
+    isLength = require('../internal/isLength');
+
+/**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection through `iteratee`. This method performs
+ * a stable sort, that is, it preserves the original sort order of equal elements.
+ * The `iteratee` is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for `predicate` the created `_.property`
+ * style callback returns the property value of the given element.
+ *
+ * If a value is also provided for `thisArg` the created `_.matchesProperty`
+ * style callback returns `true` for elements that have a matching property
+ * value, else `false`.
+ *
+ * If an object is provided for `predicate` the created `_.matches` style
+ * callback returns `true` for elements that have the properties of the given
+ * object, else `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Array|Function|Object|string} [iteratee=_.identity] The function
+ *  invoked per iteration. If a property name or an object is provided it is
+ *  used to create a `_.property` or `_.matches` style callback respectively.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * _.sortBy([1, 2, 3], function(n) {
+ *   return Math.sin(n);
+ * });
+ * // => [3, 1, 2]
+ *
+ * _.sortBy([1, 2, 3], function(n) {
+ *   return this.sin(n);
+ * }, Math);
+ * // => [3, 1, 2]
+ *
+ * var users = [
+ *   { 'user': 'fred' },
+ *   { 'user': 'pebbles' },
+ *   { 'user': 'barney' }
+ * ];
+ *
+ * // using the `_.property` callback shorthand
+ * _.pluck(_.sortBy(users, 'user'), 'user');
+ * // => ['barney', 'fred', 'pebbles']
+ */
+function sortBy(collection, iteratee, thisArg) {
+  var index = -1,
+      length = collection ? collection.length : 0,
+      result = isLength(length) ? Array(length) : [];
+
+  if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {
+    iteratee = null;
+  }
+  iteratee = baseCallback(iteratee, thisArg, 3);
+  baseEach(collection, function(value, key, collection) {
+    result[++index] = { 'criteria': iteratee(value, key, collection), 'index': index, 'value': value };
+  });
+  return baseSortBy(result, compareAscending);
+}
+
+module.exports = sortBy;
+
+},{"../internal/baseCallback":215,"../internal/baseEach":220,"../internal/baseSortBy":239,"../internal/compareAscending":247,"../internal/isIterateeCall":268,"../internal/isLength":269}],205:[function(require,module,exports){
+var isNative = require('../lang/isNative');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeNow = isNative(nativeNow = Date.now) && nativeNow;
+
+/**
+ * Gets the number of milliseconds that have elapsed since the Unix epoch
+ * (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @category Date
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => logs the number of milliseconds it took for the deferred function to be invoked
+ */
+var now = nativeNow || function() {
+  return new Date().getTime();
+};
+
+module.exports = now;
+
+},{"../lang/isNative":287}],206:[function(require,module,exports){
+var createWrapper = require('../internal/createWrapper'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/** Used to compose bitmasks for wrapper metadata. */
+var ARY_FLAG = 256;
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Creates a function that accepts up to `n` arguments ignoring any
+ * additional arguments.
+ *
+ * @static
+ * @memberOf _
+ * @category Function
+ * @param {Function} func The function to cap arguments for.
+ * @param {number} [n=func.length] The arity cap.
+ * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * _.map(['6', '8', '10'], _.ary(parseInt, 1));
+ * // => [6, 8, 10]
+ */
+function ary(func, n, guard) {
+  if (guard && isIterateeCall(func, n, guard)) {
+    n = null;
+  }
+  n = (func && n == null) ? func.length : nativeMax(+n || 0, 0);
+  return createWrapper(func, ARY_FLAG, null, null, null, null, n);
+}
+
+module.exports = ary;
+
+},{"../internal/createWrapper":257,"../internal/isIterateeCall":268}],207:[function(require,module,exports){
+(function (global){
+var cachePush = require('./cachePush'),
+    isNative = require('../lang/isNative');
+
+/** Native method references. */
+var Set = isNative(Set = global.Set) && Set;
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;
+
+/**
+ *
+ * Creates a cache object to store unique values.
+ *
+ * @private
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var length = values ? values.length : 0;
+
+  this.data = { 'hash': nativeCreate(null), 'set': new Set };
+  while (length--) {
+    this.push(values[length]);
+  }
+}
+
+// Add functions to the `Set` cache.
+SetCache.prototype.push = cachePush;
+
+module.exports = SetCache;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../lang/isNative":287,"./cachePush":246}],208:[function(require,module,exports){
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+function arrayCopy(source, array) {
+  var index = -1,
+      length = source.length;
+
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+
+module.exports = arrayCopy;
+
+},{}],209:[function(require,module,exports){
+/**
+ * A specialized version of `_.forEach` for arrays without support for callback
+ * shorthands or `this` binding.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+  var index = -1,
+      length = array.length;
+
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+module.exports = arrayEach;
+
+},{}],210:[function(require,module,exports){
+/**
+ * A specialized version of `_.map` for arrays without support for callback
+ * shorthands or `this` binding.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+module.exports = arrayMap;
+
+},{}],211:[function(require,module,exports){
+/**
+ * A specialized version of `_.reduceRight` for arrays without support for
+ * callback shorthands or `this` binding.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initFromArray] Specify using the last element of `array`
+ *  as the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduceRight(array, iteratee, accumulator, initFromArray) {
+  var length = array.length;
+  if (initFromArray && length) {
+    accumulator = array[--length];
+  }
+  while (length--) {
+    accumulator = iteratee(accumulator, array[length], length, array);
+  }
+  return accumulator;
+}
+
+module.exports = arrayReduceRight;
+
+},{}],212:[function(require,module,exports){
+/**
+ * A specialized version of `_.some` for arrays without support for callback
+ * shorthands or `this` binding.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = arraySome;
+
+},{}],213:[function(require,module,exports){
+/**
+ * Used by `_.defaults` to customize its `_.assign` use.
+ *
+ * @private
+ * @param {*} objectValue The destination object property value.
+ * @param {*} sourceValue The source object property value.
+ * @returns {*} Returns the value to assign to the destination object.
+ */
+function assignDefaults(objectValue, sourceValue) {
+  return typeof objectValue == 'undefined' ? sourceValue : objectValue;
+}
+
+module.exports = assignDefaults;
+
+},{}],214:[function(require,module,exports){
+var baseCopy = require('./baseCopy'),
+    keys = require('../object/keys');
+
+/**
+ * The base implementation of `_.assign` without support for argument juggling,
+ * multiple sources, and `this` binding `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {Function} [customizer] The function to customize assigning values.
+ * @returns {Object} Returns the destination object.
+ */
+function baseAssign(object, source, customizer) {
+  var props = keys(source);
+  if (!customizer) {
+    return baseCopy(source, object, props);
+  }
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index],
+        value = object[key],
+        result = customizer(value, source[key], key, object, source);
+
+    if ((result === result ? result !== value : value === value) ||
+        (typeof value == 'undefined' && !(key in object))) {
+      object[key] = result;
+    }
+  }
+  return object;
+}
+
+module.exports = baseAssign;
+
+},{"../object/keys":297,"./baseCopy":218}],215:[function(require,module,exports){
+var baseMatches = require('./baseMatches'),
+    baseMatchesProperty = require('./baseMatchesProperty'),
+    baseProperty = require('./baseProperty'),
+    bindCallback = require('./bindCallback'),
+    identity = require('../utility/identity'),
+    isBindable = require('./isBindable');
+
+/**
+ * The base implementation of `_.callback` which supports specifying the
+ * number of arguments to provide to `func`.
+ *
+ * @private
+ * @param {*} [func=_.identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [argCount] The number of arguments to provide to `func`.
+ * @returns {Function} Returns the callback.
+ */
+function baseCallback(func, thisArg, argCount) {
+  var type = typeof func;
+  if (type == 'function') {
+    return (typeof thisArg != 'undefined' && isBindable(func))
+      ? bindCallback(func, thisArg, argCount)
+      : func;
+  }
+  if (func == null) {
+    return identity;
+  }
+  if (type == 'object') {
+    return baseMatches(func);
+  }
+  return typeof thisArg == 'undefined'
+    ? baseProperty(func + '')
+    : baseMatchesProperty(func + '', thisArg);
+}
+
+module.exports = baseCallback;
+
+},{"../utility/identity":303,"./baseMatches":233,"./baseMatchesProperty":234,"./baseProperty":235,"./bindCallback":243,"./isBindable":266}],216:[function(require,module,exports){
+var arrayCopy = require('./arrayCopy'),
+    arrayEach = require('./arrayEach'),
+    baseCopy = require('./baseCopy'),
+    baseForOwn = require('./baseForOwn'),
+    initCloneArray = require('./initCloneArray'),
+    initCloneByTag = require('./initCloneByTag'),
+    initCloneObject = require('./initCloneObject'),
+    isArray = require('../lang/isArray'),
+    isObject = require('../lang/isObject'),
+    keys = require('../object/keys');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =
+cloneableTags[dateTag] = cloneableTags[float32Tag] =
+cloneableTags[float64Tag] = cloneableTags[int8Tag] =
+cloneableTags[int16Tag] = cloneableTags[int32Tag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[stringTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[mapTag] = cloneableTags[setTag] =
+cloneableTags[weakMapTag] = false;
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * The base implementation of `_.clone` without support for argument juggling
+ * and `this` binding `customizer` functions.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @param {Function} [customizer] The function to customize cloning values.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The object `value` belongs to.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates clones with source counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, isDeep, customizer, key, object, stackA, stackB) {
+  var result;
+  if (customizer) {
+    result = object ? customizer(value, key, object) : customizer(value);
+  }
+  if (typeof result != 'undefined') {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return arrayCopy(value, result);
+    }
+  } else {
+    var tag = objToString.call(value),
+        isFunc = tag == funcTag;
+
+    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+      result = initCloneObject(isFunc ? {} : value);
+      if (!isDeep) {
+        return baseCopy(value, result, keys(value));
+      }
+    } else {
+      return cloneableTags[tag]
+        ? initCloneByTag(value, tag, isDeep)
+        : (object ? value : {});
+    }
+  }
+  // Check for circular references and return corresponding clone.
+  stackA || (stackA = []);
+  stackB || (stackB = []);
+
+  var length = stackA.length;
+  while (length--) {
+    if (stackA[length] == value) {
+      return stackB[length];
+    }
+  }
+  // Add the source value to the stack of traversed objects and associate it with its clone.
+  stackA.push(value);
+  stackB.push(result);
+
+  // Recursively populate clone (susceptible to call stack limits).
+  (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
+    result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB);
+  });
+  return result;
+}
+
+module.exports = baseClone;
+
+},{"../lang/isArray":283,"../lang/isObject":289,"../object/keys":297,"./arrayCopy":208,"./arrayEach":209,"./baseCopy":218,"./baseForOwn":224,"./initCloneArray":263,"./initCloneByTag":264,"./initCloneObject":265}],217:[function(require,module,exports){
+/**
+ * The base implementation of `compareAscending` which compares values and
+ * sorts them in ascending order without guaranteeing a stable sort.
+ *
+ * @private
+ * @param {*} value The value to compare to `other`.
+ * @param {*} other The value to compare to `value`.
+ * @returns {number} Returns the sort order indicator for `value`.
+ */
+function baseCompareAscending(value, other) {
+  if (value !== other) {
+    var valIsReflexive = value === value,
+        othIsReflexive = other === other;
+
+    if (value > other || !valIsReflexive || (typeof value == 'undefined' && othIsReflexive)) {
+      return 1;
+    }
+    if (value < other || !othIsReflexive || (typeof other == 'undefined' && valIsReflexive)) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+module.exports = baseCompareAscending;
+
+},{}],218:[function(require,module,exports){
+/**
+ * Copies the properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Array} props The property names to copy.
+ * @returns {Object} Returns `object`.
+ */
+function baseCopy(source, object, props) {
+  if (!props) {
+    props = object;
+    object = {};
+  }
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+    object[key] = source[key];
+  }
+  return object;
+}
+
+module.exports = baseCopy;
+
+},{}],219:[function(require,module,exports){
+(function (global){
+var isObject = require('../lang/isObject');
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+  function Object() {}
+  return function(prototype) {
+    if (isObject(prototype)) {
+      Object.prototype = prototype;
+      var result = new Object;
+      Object.prototype = null;
+    }
+    return result || global.Object();
+  };
+}());
+
+module.exports = baseCreate;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../lang/isObject":289}],220:[function(require,module,exports){
+var baseForOwn = require('./baseForOwn'),
+    isLength = require('./isLength'),
+    toObject = require('./toObject');
+
+/**
+ * The base implementation of `_.forEach` without support for callback
+ * shorthands and `this` binding.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object|string} Returns `collection`.
+ */
+function baseEach(collection, iteratee) {
+  var length = collection ? collection.length : 0;
+  if (!isLength(length)) {
+    return baseForOwn(collection, iteratee);
+  }
+  var index = -1,
+      iterable = toObject(collection);
+
+  while (++index < length) {
+    if (iteratee(iterable[index], index, iterable) === false) {
+      break;
+    }
+  }
+  return collection;
+}
+
+module.exports = baseEach;
+
+},{"./baseForOwn":224,"./isLength":269,"./toObject":279}],221:[function(require,module,exports){
+var baseForOwnRight = require('./baseForOwnRight'),
+    isLength = require('./isLength'),
+    toObject = require('./toObject');
+
+/**
+ * The base implementation of `_.forEachRight` without support for callback
+ * shorthands and `this` binding.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object|string} Returns `collection`.
+ */
+function baseEachRight(collection, iteratee) {
+  var length = collection ? collection.length : 0;
+  if (!isLength(length)) {
+    return baseForOwnRight(collection, iteratee);
+  }
+  var iterable = toObject(collection);
+  while (length--) {
+    if (iteratee(iterable[length], length, iterable) === false) {
+      break;
+    }
+  }
+  return collection;
+}
+
+module.exports = baseEachRight;
+
+},{"./baseForOwnRight":225,"./isLength":269,"./toObject":279}],222:[function(require,module,exports){
+var isArguments = require('../lang/isArguments'),
+    isArray = require('../lang/isArray'),
+    isLength = require('./isLength'),
+    isObjectLike = require('./isObjectLike');
+
+/**
+ * The base implementation of `_.flatten` with added support for restricting
+ * flattening and specifying the start index.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isDeep] Specify a deep flatten.
+ * @param {boolean} [isStrict] Restrict flattening to arrays and `arguments` objects.
+ * @param {number} [fromIndex=0] The index to start from.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten(array, isDeep, isStrict, fromIndex) {
+  var index = (fromIndex || 0) - 1,
+      length = array.length,
+      resIndex = -1,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+
+    if (isObjectLike(value) && isLength(value.length) && (isArray(value) || isArguments(value))) {
+      if (isDeep) {
+        // Recursively flatten arrays (susceptible to call stack limits).
+        value = baseFlatten(value, isDeep, isStrict);
+      }
+      var valIndex = -1,
+          valLength = value.length;
+
+      result.length += valLength;
+      while (++valIndex < valLength) {
+        result[++resIndex] = value[valIndex];
+      }
+    } else if (!isStrict) {
+      result[++resIndex] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = baseFlatten;
+
+},{"../lang/isArguments":282,"../lang/isArray":283,"./isLength":269,"./isObjectLike":270}],223:[function(require,module,exports){
+var toObject = require('./toObject');
+
+/**
+ * The base implementation of `baseForIn` and `baseForOwn` which iterates
+ * over `object` properties returned by `keysFunc` invoking `iteratee` for
+ * each property. Iterator functions may exit iteration early by explicitly
+ * returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+function baseFor(object, iteratee, keysFunc) {
+  var index = -1,
+      iterable = toObject(object),
+      props = keysFunc(object),
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+    if (iteratee(iterable[key], key, iterable) === false) {
+      break;
+    }
+  }
+  return object;
+}
+
+module.exports = baseFor;
+
+},{"./toObject":279}],224:[function(require,module,exports){
+var baseFor = require('./baseFor'),
+    keys = require('../object/keys');
+
+/**
+ * The base implementation of `_.forOwn` without support for callback
+ * shorthands and `this` binding.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return baseFor(object, iteratee, keys);
+}
+
+module.exports = baseForOwn;
+
+},{"../object/keys":297,"./baseFor":223}],225:[function(require,module,exports){
+var baseForRight = require('./baseForRight'),
+    keys = require('../object/keys');
+
+/**
+ * The base implementation of `_.forOwnRight` without support for callback
+ * shorthands and `this` binding.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwnRight(object, iteratee) {
+  return baseForRight(object, iteratee, keys);
+}
+
+module.exports = baseForOwnRight;
+
+},{"../object/keys":297,"./baseForRight":226}],226:[function(require,module,exports){
+var toObject = require('./toObject');
+
+/**
+ * This function is like `baseFor` except that it iterates over properties
+ * in the opposite order.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+function baseForRight(object, iteratee, keysFunc) {
+  var iterable = toObject(object),
+      props = keysFunc(object),
+      length = props.length;
+
+  while (length--) {
+    var key = props[length];
+    if (iteratee(iterable[key], key, iterable) === false) {
+      break;
+    }
+  }
+  return object;
+}
+
+module.exports = baseForRight;
+
+},{"./toObject":279}],227:[function(require,module,exports){
+var indexOfNaN = require('./indexOfNaN');
+
+/**
+ * The base implementation of `_.indexOf` without support for binary searches.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseIndexOf(array, value, fromIndex) {
+  if (value !== value) {
+    return indexOfNaN(array, fromIndex);
+  }
+  var index = (fromIndex || 0) - 1,
+      length = array.length;
+
+  while (++index < length) {
+    if (array[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+module.exports = baseIndexOf;
+
+},{"./indexOfNaN":262}],228:[function(require,module,exports){
+var baseIsEqualDeep = require('./baseIsEqualDeep');
+
+/**
+ * The base implementation of `_.isEqual` without support for `this` binding
+ * `customizer` functions.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {Function} [customizer] The function to customize comparing values.
+ * @param {boolean} [isWhere] Specify performing partial comparisons.
+ * @param {Array} [stackA] Tracks traversed `value` objects.
+ * @param {Array} [stackB] Tracks traversed `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, customizer, isWhere, stackA, stackB) {
+  // Exit early for identical values.
+  if (value === other) {
+    // Treat `+0` vs. `-0` as not equal.
+    return value !== 0 || (1 / value == 1 / other);
+  }
+  var valType = typeof value,
+      othType = typeof other;
+
+  // Exit early for unlike primitive values.
+  if ((valType != 'function' && valType != 'object' && othType != 'function' && othType != 'object') ||
+      value == null || other == null) {
+    // Return `false` unless both values are `NaN`.
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, baseIsEqual, customizer, isWhere, stackA, stackB);
+}
+
+module.exports = baseIsEqual;
+
+},{"./baseIsEqualDeep":229}],229:[function(require,module,exports){
+var equalArrays = require('./equalArrays'),
+    equalByTag = require('./equalByTag'),
+    equalObjects = require('./equalObjects'),
+    isArray = require('../lang/isArray'),
+    isTypedArray = require('../lang/isTypedArray');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} [customizer] The function to customize comparing objects.
+ * @param {boolean} [isWhere] Specify performing partial comparisons.
+ * @param {Array} [stackA=[]] Tracks traversed `value` objects.
+ * @param {Array} [stackB=[]] Tracks traversed `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, equalFunc, customizer, isWhere, stackA, stackB) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = arrayTag,
+      othTag = arrayTag;
+
+  if (!objIsArr) {
+    objTag = objToString.call(object);
+    if (objTag == argsTag) {
+      objTag = objectTag;
+    } else if (objTag != objectTag) {
+      objIsArr = isTypedArray(object);
+    }
+  }
+  if (!othIsArr) {
+    othTag = objToString.call(other);
+    if (othTag == argsTag) {
+      othTag = objectTag;
+    } else if (othTag != objectTag) {
+      othIsArr = isTypedArray(other);
+    }
+  }
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && !(objIsArr || objIsObj)) {
+    return equalByTag(object, other, objTag);
+  }
+  var valWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+      othWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+  if (valWrapped || othWrapped) {
+    return equalFunc(valWrapped ? object.value() : object, othWrapped ? other.value() : other, customizer, isWhere, stackA, stackB);
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  // Assume cyclic values are equal.
+  // For more information on detecting circular references see https://es5.github.io/#JO.
+  stackA || (stackA = []);
+  stackB || (stackB = []);
+
+  var length = stackA.length;
+  while (length--) {
+    if (stackA[length] == object) {
+      return stackB[length] == other;
+    }
+  }
+  // Add `object` and `other` to the stack of traversed objects.
+  stackA.push(object);
+  stackB.push(other);
+
+  var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isWhere, stackA, stackB);
+
+  stackA.pop();
+  stackB.pop();
+
+  return result;
+}
+
+module.exports = baseIsEqualDeep;
+
+},{"../lang/isArray":283,"../lang/isTypedArray":292,"./equalArrays":258,"./equalByTag":259,"./equalObjects":260}],230:[function(require,module,exports){
+/**
+ * The base implementation of `_.isFunction` without support for environments
+ * with incorrect `typeof` results.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ */
+function baseIsFunction(value) {
+  // Avoid a Chakra JIT bug in compatibility modes of IE 11.
+  // See https://github.com/jashkenas/underscore/issues/1621 for more details.
+  return typeof value == 'function' || false;
+}
+
+module.exports = baseIsFunction;
+
+},{}],231:[function(require,module,exports){
+var baseIsEqual = require('./baseIsEqual');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.isMatch` without support for callback
+ * shorthands or `this` binding.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Array} props The source property names to match.
+ * @param {Array} values The source values to match.
+ * @param {Array} strictCompareFlags Strict comparison flags for source values.
+ * @param {Function} [customizer] The function to customize comparing objects.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, props, values, strictCompareFlags, customizer) {
+  var length = props.length;
+  if (object == null) {
+    return !length;
+  }
+  var index = -1,
+      noCustomizer = !customizer;
+
+  while (++index < length) {
+    if ((noCustomizer && strictCompareFlags[index])
+          ? values[index] !== object[props[index]]
+          : !hasOwnProperty.call(object, props[index])
+        ) {
+      return false;
+    }
+  }
+  index = -1;
+  while (++index < length) {
+    var key = props[index];
+    if (noCustomizer && strictCompareFlags[index]) {
+      var result = hasOwnProperty.call(object, key);
+    } else {
+      var objValue = object[key],
+          srcValue = values[index];
+
+      result = customizer ? customizer(objValue, srcValue, key) : undefined;
+      if (typeof result == 'undefined') {
+        result = baseIsEqual(srcValue, objValue, customizer, true);
+      }
+    }
+    if (!result) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = baseIsMatch;
+
+},{"./baseIsEqual":228}],232:[function(require,module,exports){
+var baseEach = require('./baseEach');
+
+/**
+ * The base implementation of `_.map` without support for callback shorthands
+ * or `this` binding.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function baseMap(collection, iteratee) {
+  var result = [];
+  baseEach(collection, function(value, key, collection) {
+    result.push(iteratee(value, key, collection));
+  });
+  return result;
+}
+
+module.exports = baseMap;
+
+},{"./baseEach":220}],233:[function(require,module,exports){
+var baseIsMatch = require('./baseIsMatch'),
+    isStrictComparable = require('./isStrictComparable'),
+    keys = require('../object/keys');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.matches` which does not clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new function.
+ */
+function baseMatches(source) {
+  var props = keys(source),
+      length = props.length;
+
+  if (length == 1) {
+    var key = props[0],
+        value = source[key];
+
+    if (isStrictComparable(value)) {
+      return function(object) {
+        return object != null && object[key] === value && hasOwnProperty.call(object, key);
+      };
+    }
+  }
+  var values = Array(length),
+      strictCompareFlags = Array(length);
+
+  while (length--) {
+    value = source[props[length]];
+    values[length] = value;
+    strictCompareFlags[length] = isStrictComparable(value);
+  }
+  return function(object) {
+    return baseIsMatch(object, props, values, strictCompareFlags);
+  };
+}
+
+module.exports = baseMatches;
+
+},{"../object/keys":297,"./baseIsMatch":231,"./isStrictComparable":271}],234:[function(require,module,exports){
+var baseIsEqual = require('./baseIsEqual'),
+    isStrictComparable = require('./isStrictComparable');
+
+/**
+ * The base implementation of `_.matchesProperty` which does not coerce `key`
+ * to a string.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} value The value to compare.
+ * @returns {Function} Returns the new function.
+ */
+function baseMatchesProperty(key, value) {
+  if (isStrictComparable(value)) {
+    return function(object) {
+      return object != null && object[key] === value;
+    };
+  }
+  return function(object) {
+    return object != null && baseIsEqual(value, object[key], null, true);
+  };
+}
+
+module.exports = baseMatchesProperty;
+
+},{"./baseIsEqual":228,"./isStrictComparable":271}],235:[function(require,module,exports){
+/**
+ * The base implementation of `_.property` which does not coerce `key` to a string.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new function.
+ */
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+module.exports = baseProperty;
+
+},{}],236:[function(require,module,exports){
+/**
+ * The base implementation of `_.reduce` and `_.reduceRight` without support
+ * for callback shorthands or `this` binding, which iterates over `collection`
+ * using the provided `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} accumulator The initial value.
+ * @param {boolean} initFromCollection Specify using the first or last element
+ *  of `collection` as the initial value.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the accumulated value.
+ */
+function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) {
+  eachFunc(collection, function(value, index, collection) {
+    accumulator = initFromCollection
+      ? (initFromCollection = false, value)
+      : iteratee(accumulator, value, index, collection);
+  });
+  return accumulator;
+}
+
+module.exports = baseReduce;
+
+},{}],237:[function(require,module,exports){
+var identity = require('../utility/identity'),
+    metaMap = require('./metaMap');
+
+/**
+ * The base implementation of `setData` without support for hot loop detection.
+ *
+ * @private
+ * @param {Function} func The function to associate metadata with.
+ * @param {*} data The metadata.
+ * @returns {Function} Returns `func`.
+ */
+var baseSetData = !metaMap ? identity : function(func, data) {
+  metaMap.set(func, data);
+  return func;
+};
+
+module.exports = baseSetData;
+
+},{"../utility/identity":303,"./metaMap":273}],238:[function(require,module,exports){
+var baseEach = require('./baseEach');
+
+/**
+ * The base implementation of `_.some` without support for callback shorthands
+ * or `this` binding.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function baseSome(collection, predicate) {
+  var result;
+
+  baseEach(collection, function(value, index, collection) {
+    result = predicate(value, index, collection);
+    return !result;
+  });
+  return !!result;
+}
+
+module.exports = baseSome;
+
+},{"./baseEach":220}],239:[function(require,module,exports){
+/**
+ * The base implementation of `_.sortBy` and `_.sortByAll` which uses `comparer`
+ * to define the sort order of `array` and replaces criteria objects with their
+ * corresponding values.
+ *
+ * @private
+ * @param {Array} array The array to sort.
+ * @param {Function} comparer The function to define sort order.
+ * @returns {Array} Returns `array`.
+ */
+function baseSortBy(array, comparer) {
+  var length = array.length;
+
+  array.sort(comparer);
+  while (length--) {
+    array[length] = array[length].value;
+  }
+  return array;
+}
+
+module.exports = baseSortBy;
+
+},{}],240:[function(require,module,exports){
+/**
+ * Converts `value` to a string if it is not one. An empty string is returned
+ * for `null` or `undefined` values.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  if (typeof value == 'string') {
+    return value;
+  }
+  return value == null ? '' : (value + '');
+}
+
+module.exports = baseToString;
+
+},{}],241:[function(require,module,exports){
+var baseIndexOf = require('./baseIndexOf'),
+    cacheIndexOf = require('./cacheIndexOf'),
+    createCache = require('./createCache');
+
+/**
+ * The base implementation of `_.uniq` without support for callback shorthands
+ * and `this` binding.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The function invoked per iteration.
+ * @returns {Array} Returns the new duplicate-value-free array.
+ */
+function baseUniq(array, iteratee) {
+  var index = -1,
+      indexOf = baseIndexOf,
+      length = array.length,
+      isCommon = true,
+      isLarge = isCommon && length >= 200,
+      seen = isLarge ? createCache() : null,
+      result = [];
+
+  if (seen) {
+    indexOf = cacheIndexOf;
+    isCommon = false;
+  } else {
+    isLarge = false;
+    seen = iteratee ? [] : result;
+  }
+  outer:
+  while (++index < length) {
+    var value = array[index],
+        computed = iteratee ? iteratee(value, index, array) : value;
+
+    if (isCommon && value === value) {
+      var seenIndex = seen.length;
+      while (seenIndex--) {
+        if (seen[seenIndex] === computed) {
+          continue outer;
+        }
+      }
+      if (iteratee) {
+        seen.push(computed);
+      }
+      result.push(value);
+    }
+    else if (indexOf(seen, computed) < 0) {
+      if (iteratee || isLarge) {
+        seen.push(computed);
+      }
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+module.exports = baseUniq;
+
+},{"./baseIndexOf":227,"./cacheIndexOf":245,"./createCache":253}],242:[function(require,module,exports){
+/**
+ * The base implementation of `_.values` and `_.valuesIn` which creates an
+ * array of `object` property values corresponding to the property names
+ * returned by `keysFunc`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} props The property names to get values for.
+ * @returns {Object} Returns the array of property values.
+ */
+function baseValues(object, props) {
+  var index = -1,
+      length = props.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = object[props[index]];
+  }
+  return result;
+}
+
+module.exports = baseValues;
+
+},{}],243:[function(require,module,exports){
+var identity = require('../utility/identity');
+
+/**
+ * A specialized version of `baseCallback` which only supports `this` binding
+ * and specifying the number of arguments to provide to `func`.
+ *
+ * @private
+ * @param {Function} func The function to bind.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {number} [argCount] The number of arguments to provide to `func`.
+ * @returns {Function} Returns the callback.
+ */
+function bindCallback(func, thisArg, argCount) {
+  if (typeof func != 'function') {
+    return identity;
+  }
+  if (typeof thisArg == 'undefined') {
+    return func;
+  }
+  switch (argCount) {
+    case 1: return function(value) {
+      return func.call(thisArg, value);
+    };
+    case 3: return function(value, index, collection) {
+      return func.call(thisArg, value, index, collection);
+    };
+    case 4: return function(accumulator, value, index, collection) {
+      return func.call(thisArg, accumulator, value, index, collection);
+    };
+    case 5: return function(value, other, key, object, source) {
+      return func.call(thisArg, value, other, key, object, source);
+    };
+  }
+  return function() {
+    return func.apply(thisArg, arguments);
+  };
+}
+
+module.exports = bindCallback;
+
+},{"../utility/identity":303}],244:[function(require,module,exports){
+(function (global){
+var constant = require('../utility/constant'),
+    isNative = require('../lang/isNative');
+
+/** Native method references. */
+var ArrayBuffer = isNative(ArrayBuffer = global.ArrayBuffer) && ArrayBuffer,
+    bufferSlice = isNative(bufferSlice = ArrayBuffer && new ArrayBuffer(0).slice) && bufferSlice,
+    floor = Math.floor,
+    Uint8Array = isNative(Uint8Array = global.Uint8Array) && Uint8Array;
+
+/** Used to clone array buffers. */
+var Float64Array = (function() {
+  // Safari 5 errors when using an array buffer to initialize a typed array
+  // where the array buffer's `byteLength` is not a multiple of the typed
+  // array's `BYTES_PER_ELEMENT`.
+  try {
+    var func = isNative(func = global.Float64Array) && func,
+        result = new func(new ArrayBuffer(10), 0, 1) && func;
+  } catch(e) {}
+  return result;
+}());
+
+/** Used as the size, in bytes, of each `Float64Array` element. */
+var FLOAT64_BYTES_PER_ELEMENT = Float64Array ? Float64Array.BYTES_PER_ELEMENT : 0;
+
+/**
+ * Creates a clone of the given array buffer.
+ *
+ * @private
+ * @param {ArrayBuffer} buffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function bufferClone(buffer) {
+  return bufferSlice.call(buffer, 0);
+}
+if (!bufferSlice) {
+  // PhantomJS has `ArrayBuffer` and `Uint8Array` but not `Float64Array`.
+  bufferClone = !(ArrayBuffer && Uint8Array) ? constant(null) : function(buffer) {
+    var byteLength = buffer.byteLength,
+        floatLength = Float64Array ? floor(byteLength / FLOAT64_BYTES_PER_ELEMENT) : 0,
+        offset = floatLength * FLOAT64_BYTES_PER_ELEMENT,
+        result = new ArrayBuffer(byteLength);
+
+    if (floatLength) {
+      var view = new Float64Array(result, 0, floatLength);
+      view.set(new Float64Array(buffer, 0, floatLength));
+    }
+    if (byteLength != offset) {
+      view = new Uint8Array(result, offset);
+      view.set(new Uint8Array(buffer, offset));
+    }
+    return result;
+  };
+}
+
+module.exports = bufferClone;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../lang/isNative":287,"../utility/constant":302}],245:[function(require,module,exports){
+var isObject = require('../lang/isObject');
+
+/**
+ * Checks if `value` is in `cache` mimicking the return signature of
+ * `_.indexOf` by returning `0` if the value is found, else `-1`.
+ *
+ * @private
+ * @param {Object} cache The cache to search.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `0` if `value` is found, else `-1`.
+ */
+function cacheIndexOf(cache, value) {
+  var data = cache.data,
+      result = (typeof value == 'string' || isObject(value)) ? data.set.has(value) : data.hash[value];
+
+  return result ? 0 : -1;
+}
+
+module.exports = cacheIndexOf;
+
+},{"../lang/isObject":289}],246:[function(require,module,exports){
+var isObject = require('../lang/isObject');
+
+/**
+ * Adds `value` to the cache.
+ *
+ * @private
+ * @name push
+ * @memberOf SetCache
+ * @param {*} value The value to cache.
+ */
+function cachePush(value) {
+  var data = this.data;
+  if (typeof value == 'string' || isObject(value)) {
+    data.set.add(value);
+  } else {
+    data.hash[value] = true;
+  }
+}
+
+module.exports = cachePush;
+
+},{"../lang/isObject":289}],247:[function(require,module,exports){
+var baseCompareAscending = require('./baseCompareAscending');
+
+/**
+ * Used by `_.sortBy` to compare transformed elements of a collection and stable
+ * sort them in ascending order.
+ *
+ * @private
+ * @param {Object} object The object to compare to `other`.
+ * @param {Object} other The object to compare to `object`.
+ * @returns {number} Returns the sort order indicator for `object`.
+ */
+function compareAscending(object, other) {
+  return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);
+}
+
+module.exports = compareAscending;
+
+},{"./baseCompareAscending":217}],248:[function(require,module,exports){
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Creates an array that is the composition of partially applied arguments,
+ * placeholders, and provided arguments into a single array of arguments.
+ *
+ * @private
+ * @param {Array|Object} args The provided arguments.
+ * @param {Array} partials The arguments to prepend to those provided.
+ * @param {Array} holders The `partials` placeholder indexes.
+ * @returns {Array} Returns the new array of composed arguments.
+ */
+function composeArgs(args, partials, holders) {
+  var holdersLength = holders.length,
+      argsIndex = -1,
+      argsLength = nativeMax(args.length - holdersLength, 0),
+      leftIndex = -1,
+      leftLength = partials.length,
+      result = Array(argsLength + leftLength);
+
+  while (++leftIndex < leftLength) {
+    result[leftIndex] = partials[leftIndex];
+  }
+  while (++argsIndex < holdersLength) {
+    result[holders[argsIndex]] = args[argsIndex];
+  }
+  while (argsLength--) {
+    result[leftIndex++] = args[argsIndex++];
+  }
+  return result;
+}
+
+module.exports = composeArgs;
+
+},{}],249:[function(require,module,exports){
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * This function is like `composeArgs` except that the arguments composition
+ * is tailored for `_.partialRight`.
+ *
+ * @private
+ * @param {Array|Object} args The provided arguments.
+ * @param {Array} partials The arguments to append to those provided.
+ * @param {Array} holders The `partials` placeholder indexes.
+ * @returns {Array} Returns the new array of composed arguments.
+ */
+function composeArgsRight(args, partials, holders) {
+  var holdersIndex = -1,
+      holdersLength = holders.length,
+      argsIndex = -1,
+      argsLength = nativeMax(args.length - holdersLength, 0),
+      rightIndex = -1,
+      rightLength = partials.length,
+      result = Array(argsLength + rightLength);
+
+  while (++argsIndex < argsLength) {
+    result[argsIndex] = args[argsIndex];
+  }
+  var pad = argsIndex;
+  while (++rightIndex < rightLength) {
+    result[pad + rightIndex] = partials[rightIndex];
+  }
+  while (++holdersIndex < holdersLength) {
+    result[pad + holders[holdersIndex]] = args[argsIndex++];
+  }
+  return result;
+}
+
+module.exports = composeArgsRight;
+
+},{}],250:[function(require,module,exports){
+var baseCallback = require('./baseCallback'),
+    baseEach = require('./baseEach'),
+    isArray = require('../lang/isArray');
+
+/**
+ * Creates a function that aggregates a collection, creating an accumulator
+ * object composed from the results of running each element in the collection
+ * through an iteratee.
+ *
+ * @private
+ * @param {Function} setter The function to set keys and values of the accumulator object.
+ * @param {Function} [initializer] The function to initialize the accumulator object.
+ * @returns {Function} Returns the new aggregator function.
+ */
+function createAggregator(setter, initializer) {
+  return function(collection, iteratee, thisArg) {
+    var result = initializer ? initializer() : {};
+    iteratee = baseCallback(iteratee, thisArg, 3);
+
+    if (isArray(collection)) {
+      var index = -1,
+          length = collection.length;
+
+      while (++index < length) {
+        var value = collection[index];
+        setter(result, value, iteratee(value, index, collection), collection);
+      }
+    } else {
+      baseEach(collection, function(value, key, collection) {
+        setter(result, value, iteratee(value, key, collection), collection);
+      });
+    }
+    return result;
+  };
+}
+
+module.exports = createAggregator;
+
+},{"../lang/isArray":283,"./baseCallback":215,"./baseEach":220}],251:[function(require,module,exports){
+var bindCallback = require('./bindCallback'),
+    isIterateeCall = require('./isIterateeCall');
+
+/**
+ * Creates a function that assigns properties of source object(s) to a given
+ * destination object.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+  return function() {
+    var length = arguments.length,
+        object = arguments[0];
+
+    if (length < 2 || object == null) {
+      return object;
+    }
+    if (length > 3 && isIterateeCall(arguments[1], arguments[2], arguments[3])) {
+      length = 2;
+    }
+    // Juggle arguments.
+    if (length > 3 && typeof arguments[length - 2] == 'function') {
+      var customizer = bindCallback(arguments[--length - 1], arguments[length--], 5);
+    } else if (length > 2 && typeof arguments[length - 1] == 'function') {
+      customizer = arguments[--length];
+    }
+    var index = 0;
+    while (++index < length) {
+      var source = arguments[index];
+      if (source) {
+        assigner(object, source, customizer);
+      }
+    }
+    return object;
+  };
+}
+
+module.exports = createAssigner;
+
+},{"./bindCallback":243,"./isIterateeCall":268}],252:[function(require,module,exports){
+var createCtorWrapper = require('./createCtorWrapper');
+
+/**
+ * Creates a function that wraps `func` and invokes it with the `this`
+ * binding of `thisArg`.
+ *
+ * @private
+ * @param {Function} func The function to bind.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @returns {Function} Returns the new bound function.
+ */
+function createBindWrapper(func, thisArg) {
+  var Ctor = createCtorWrapper(func);
+
+  function wrapper() {
+    return (this instanceof wrapper ? Ctor : func).apply(thisArg, arguments);
+  }
+  return wrapper;
+}
+
+module.exports = createBindWrapper;
+
+},{"./createCtorWrapper":254}],253:[function(require,module,exports){
+(function (global){
+var SetCache = require('./SetCache'),
+    constant = require('../utility/constant'),
+    isNative = require('../lang/isNative');
+
+/** Native method references. */
+var Set = isNative(Set = global.Set) && Set;
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;
+
+/**
+ * Creates a `Set` cache object to optimize linear searches of large arrays.
+ *
+ * @private
+ * @param {Array} [values] The values to cache.
+ * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`.
+ */
+var createCache = !(nativeCreate && Set) ? constant(null) : function(values) {
+  return new SetCache(values);
+};
+
+module.exports = createCache;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../lang/isNative":287,"../utility/constant":302,"./SetCache":207}],254:[function(require,module,exports){
+var baseCreate = require('./baseCreate'),
+    isObject = require('../lang/isObject');
+
+/**
+ * Creates a function that produces an instance of `Ctor` regardless of
+ * whether it was invoked as part of a `new` expression or by `call` or `apply`.
+ *
+ * @private
+ * @param {Function} Ctor The constructor to wrap.
+ * @returns {Function} Returns the new wrapped function.
+ */
+function createCtorWrapper(Ctor) {
+  return function() {
+    var thisBinding = baseCreate(Ctor.prototype),
+        result = Ctor.apply(thisBinding, arguments);
+
+    // Mimic the constructor's `return` behavior.
+    // See https://es5.github.io/#x13.2.2 for more details.
+    return isObject(result) ? result : thisBinding;
+  };
+}
+
+module.exports = createCtorWrapper;
+
+},{"../lang/isObject":289,"./baseCreate":219}],255:[function(require,module,exports){
+var arrayCopy = require('./arrayCopy'),
+    composeArgs = require('./composeArgs'),
+    composeArgsRight = require('./composeArgsRight'),
+    createCtorWrapper = require('./createCtorWrapper'),
+    reorder = require('./reorder'),
+    replaceHolders = require('./replaceHolders');
+
+/** Used to compose bitmasks for wrapper metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    CURRY_BOUND_FLAG = 4,
+    CURRY_FLAG = 8,
+    CURRY_RIGHT_FLAG = 16,
+    PARTIAL_FLAG = 32,
+    PARTIAL_RIGHT_FLAG = 64,
+    ARY_FLAG = 256;
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Creates a function that wraps `func` and invokes it with optional `this`
+ * binding of, partial application, and currying.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {Array} [partials] The arguments to prepend to those provided to the new function.
+ * @param {Array} [holders] The `partials` placeholder indexes.
+ * @param {Array} [partialsRight] The arguments to append to those provided to the new function.
+ * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
+ * @param {Array} [argPos] The argument positions of the new function.
+ * @param {number} [ary] The arity cap of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+function createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
+  var isAry = bitmask & ARY_FLAG,
+      isBind = bitmask & BIND_FLAG,
+      isBindKey = bitmask & BIND_KEY_FLAG,
+      isCurry = bitmask & CURRY_FLAG,
+      isCurryBound = bitmask & CURRY_BOUND_FLAG,
+      isCurryRight = bitmask & CURRY_RIGHT_FLAG;
+
+  var Ctor = !isBindKey && createCtorWrapper(func),
+      key = func;
+
+  function wrapper() {
+    // Avoid `arguments` object use disqualifying optimizations by
+    // converting it to an array before providing it to other functions.
+    var length = arguments.length,
+        index = length,
+        args = Array(length);
+
+    while (index--) {
+      args[index] = arguments[index];
+    }
+    if (partials) {
+      args = composeArgs(args, partials, holders);
+    }
+    if (partialsRight) {
+      args = composeArgsRight(args, partialsRight, holdersRight);
+    }
+    if (isCurry || isCurryRight) {
+      var placeholder = wrapper.placeholder,
+          argsHolders = replaceHolders(args, placeholder);
+
+      length -= argsHolders.length;
+      if (length < arity) {
+        var newArgPos = argPos ? arrayCopy(argPos) : null,
+            newArity = nativeMax(arity - length, 0),
+            newsHolders = isCurry ? argsHolders : null,
+            newHoldersRight = isCurry ? null : argsHolders,
+            newPartials = isCurry ? args : null,
+            newPartialsRight = isCurry ? null : args;
+
+        bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);
+        bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
+
+        if (!isCurryBound) {
+          bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
+        }
+        var result = createHybridWrapper(func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, newArity);
+        result.placeholder = placeholder;
+        return result;
+      }
+    }
+    var thisBinding = isBind ? thisArg : this;
+    if (isBindKey) {
+      func = thisBinding[key];
+    }
+    if (argPos) {
+      args = reorder(args, argPos);
+    }
+    if (isAry && ary < args.length) {
+      args.length = ary;
+    }
+    return (this instanceof wrapper ? (Ctor || createCtorWrapper(func)) : func).apply(thisBinding, args);
+  }
+  return wrapper;
+}
+
+module.exports = createHybridWrapper;
+
+},{"./arrayCopy":208,"./composeArgs":248,"./composeArgsRight":249,"./createCtorWrapper":254,"./reorder":274,"./replaceHolders":275}],256:[function(require,module,exports){
+var createCtorWrapper = require('./createCtorWrapper');
+
+/** Used to compose bitmasks for wrapper metadata. */
+var BIND_FLAG = 1;
+
+/**
+ * Creates a function that wraps `func` and invokes it with the optional `this`
+ * binding of `thisArg` and the `partials` prepended to those provided to
+ * the wrapper.
+ *
+ * @private
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} partials The arguments to prepend to those provided to the new function.
+ * @returns {Function} Returns the new bound function.
+ */
+function createPartialWrapper(func, bitmask, thisArg, partials) {
+  var isBind = bitmask & BIND_FLAG,
+      Ctor = createCtorWrapper(func);
+
+  function wrapper() {
+    // Avoid `arguments` object use disqualifying optimizations by
+    // converting it to an array before providing it `func`.
+    var argsIndex = -1,
+        argsLength = arguments.length,
+        leftIndex = -1,
+        leftLength = partials.length,
+        args = Array(argsLength + leftLength);
+
+    while (++leftIndex < leftLength) {
+      args[leftIndex] = partials[leftIndex];
+    }
+    while (argsLength--) {
+      args[leftIndex++] = arguments[++argsIndex];
+    }
+    return (this instanceof wrapper ? Ctor : func).apply(isBind ? thisArg : this, args);
+  }
+  return wrapper;
+}
+
+module.exports = createPartialWrapper;
+
+},{"./createCtorWrapper":254}],257:[function(require,module,exports){
+var baseSetData = require('./baseSetData'),
+    createBindWrapper = require('./createBindWrapper'),
+    createHybridWrapper = require('./createHybridWrapper'),
+    createPartialWrapper = require('./createPartialWrapper'),
+    getData = require('./getData'),
+    mergeData = require('./mergeData'),
+    setData = require('./setData');
+
+/** Used to compose bitmasks for wrapper metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    PARTIAL_FLAG = 32,
+    PARTIAL_RIGHT_FLAG = 64;
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Creates a function that either curries or invokes `func` with optional
+ * `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of flags.
+ *  The bitmask may be composed of the following flags:
+ *     1 - `_.bind`
+ *     2 - `_.bindKey`
+ *     4 - `_.curry` or `_.curryRight` of a bound function
+ *     8 - `_.curry`
+ *    16 - `_.curryRight`
+ *    32 - `_.partial`
+ *    64 - `_.partialRight`
+ *   128 - `_.rearg`
+ *   256 - `_.ary`
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {Array} [partials] The arguments to be partially applied.
+ * @param {Array} [holders] The `partials` placeholder indexes.
+ * @param {Array} [argPos] The argument positions of the new function.
+ * @param {number} [ary] The arity cap of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new wrapped function.
+ */
+function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
+  var isBindKey = bitmask & BIND_KEY_FLAG;
+  if (!isBindKey && typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var length = partials ? partials.length : 0;
+  if (!length) {
+    bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
+    partials = holders = null;
+  }
+  length -= (holders ? holders.length : 0);
+  if (bitmask & PARTIAL_RIGHT_FLAG) {
+    var partialsRight = partials,
+        holdersRight = holders;
+
+    partials = holders = null;
+  }
+  var data = !isBindKey && getData(func),
+      newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity];
+
+  if (data && data !== true) {
+    mergeData(newData, data);
+    bitmask = newData[1];
+    arity = newData[9];
+  }
+  newData[9] = arity == null
+    ? (isBindKey ? 0 : func.length)
+    : (nativeMax(arity - length, 0) || 0);
+
+  if (bitmask == BIND_FLAG) {
+    var result = createBindWrapper(newData[0], newData[2]);
+  } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !newData[4].length) {
+    result = createPartialWrapper.apply(undefined, newData);
+  } else {
+    result = createHybridWrapper.apply(undefined, newData);
+  }
+  var setter = data ? baseSetData : setData;
+  return setter(result, newData);
+}
+
+module.exports = createWrapper;
+
+},{"./baseSetData":237,"./createBindWrapper":252,"./createHybridWrapper":255,"./createPartialWrapper":256,"./getData":261,"./mergeData":272,"./setData":276}],258:[function(require,module,exports){
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} [customizer] The function to customize comparing arrays.
+ * @param {boolean} [isWhere] Specify performing partial comparisons.
+ * @param {Array} [stackA] Tracks traversed `value` objects.
+ * @param {Array} [stackB] Tracks traversed `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, equalFunc, customizer, isWhere, stackA, stackB) {
+  var index = -1,
+      arrLength = array.length,
+      othLength = other.length,
+      result = true;
+
+  if (arrLength != othLength && !(isWhere && othLength > arrLength)) {
+    return false;
+  }
+  // Deep compare the contents, ignoring non-numeric properties.
+  while (result && ++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    result = undefined;
+    if (customizer) {
+      result = isWhere
+        ? customizer(othValue, arrValue, index)
+        : customizer(arrValue, othValue, index);
+    }
+    if (typeof result == 'undefined') {
+      // Recursively compare arrays (susceptible to call stack limits).
+      if (isWhere) {
+        var othIndex = othLength;
+        while (othIndex--) {
+          othValue = other[othIndex];
+          result = (arrValue && arrValue === othValue) || equalFunc(arrValue, othValue, customizer, isWhere, stackA, stackB);
+          if (result) {
+            break;
+          }
+        }
+      } else {
+        result = (arrValue && arrValue === othValue) || equalFunc(arrValue, othValue, customizer, isWhere, stackA, stackB);
+      }
+    }
+  }
+  return !!result;
+}
+
+module.exports = equalArrays;
+
+},{}],259:[function(require,module,exports){
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    stringTag = '[object String]';
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} value The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag) {
+  switch (tag) {
+    case boolTag:
+    case dateTag:
+      // Coerce dates and booleans to numbers, dates to milliseconds and booleans
+      // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
+      return +object == +other;
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case numberTag:
+      // Treat `NaN` vs. `NaN` as equal.
+      return (object != +object)
+        ? other != +other
+        // But, treat `-0` vs. `+0` as not equal.
+        : (object == 0 ? ((1 / object) == (1 / other)) : object == +other);
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings primitives and string
+      // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
+      return object == (other + '');
+  }
+  return false;
+}
+
+module.exports = equalByTag;
+
+},{}],260:[function(require,module,exports){
+var keys = require('../object/keys');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Function} [customizer] The function to customize comparing values.
+ * @param {boolean} [isWhere] Specify performing partial comparisons.
+ * @param {Array} [stackA] Tracks traversed `value` objects.
+ * @param {Array} [stackB] Tracks traversed `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, equalFunc, customizer, isWhere, stackA, stackB) {
+  var objProps = keys(object),
+      objLength = objProps.length,
+      othProps = keys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isWhere) {
+    return false;
+  }
+  var hasCtor,
+      index = -1;
+
+  while (++index < objLength) {
+    var key = objProps[index],
+        result = hasOwnProperty.call(other, key);
+
+    if (result) {
+      var objValue = object[key],
+          othValue = other[key];
+
+      result = undefined;
+      if (customizer) {
+        result = isWhere
+          ? customizer(othValue, objValue, key)
+          : customizer(objValue, othValue, key);
+      }
+      if (typeof result == 'undefined') {
+        // Recursively compare objects (susceptible to call stack limits).
+        result = (objValue && objValue === othValue) || equalFunc(objValue, othValue, customizer, isWhere, stackA, stackB);
+      }
+    }
+    if (!result) {
+      return false;
+    }
+    hasCtor || (hasCtor = key == 'constructor');
+  }
+  if (!hasCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+    // Non `Object` object instances with different constructors are not equal.
+    if (objCtor != othCtor && ('constructor' in object && 'constructor' in other) &&
+        !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = equalObjects;
+
+},{"../object/keys":297}],261:[function(require,module,exports){
+var metaMap = require('./metaMap'),
+    noop = require('../utility/noop');
+
+/**
+ * Gets metadata for `func`.
+ *
+ * @private
+ * @param {Function} func The function to query.
+ * @returns {*} Returns the metadata for `func`.
+ */
+var getData = !metaMap ? noop : function(func) {
+  return metaMap.get(func);
+};
+
+module.exports = getData;
+
+},{"../utility/noop":304,"./metaMap":273}],262:[function(require,module,exports){
+/**
+ * Gets the index at which the first occurrence of `NaN` is found in `array`.
+ * If `fromRight` is provided elements of `array` are iterated from right to left.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {number} [fromIndex] The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched `NaN`, else `-1`.
+ */
+function indexOfNaN(array, fromIndex, fromRight) {
+  var length = array.length,
+      index = fromRight ? (fromIndex || length) : ((fromIndex || 0) - 1);
+
+  while ((fromRight ? index-- : ++index < length)) {
+    var other = array[index];
+    if (other !== other) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+module.exports = indexOfNaN;
+
+},{}],263:[function(require,module,exports){
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Initializes an array clone.
+ *
+ * @private
+ * @param {Array} array The array to clone.
+ * @returns {Array} Returns the initialized clone.
+ */
+function initCloneArray(array) {
+  var length = array.length,
+      result = new array.constructor(length);
+
+  // Add array properties assigned by `RegExp#exec`.
+  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+
+module.exports = initCloneArray;
+
+},{}],264:[function(require,module,exports){
+var bufferClone = require('./bufferClone');
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    stringTag = '[object String]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+
+/**
+ * Initializes an object clone based on its `toStringTag`.
+ *
+ * **Note:** This function only supports cloning values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @param {string} tag The `toStringTag` of the object to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag:
+      return bufferClone(object);
+
+    case boolTag:
+    case dateTag:
+      return new Ctor(+object);
+
+    case float32Tag: case float64Tag:
+    case int8Tag: case int16Tag: case int32Tag:
+    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+      var buffer = object.buffer;
+      return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length);
+
+    case numberTag:
+    case stringTag:
+      return new Ctor(object);
+
+    case regexpTag:
+      var result = new Ctor(object.source, reFlags.exec(object));
+      result.lastIndex = object.lastIndex;
+  }
+  return result;
+}
+
+module.exports = initCloneByTag;
+
+},{"./bufferClone":244}],265:[function(require,module,exports){
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneObject(object) {
+  var Ctor = object.constructor;
+  if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) {
+    Ctor = Object;
+  }
+  return new Ctor;
+}
+
+module.exports = initCloneObject;
+
+},{}],266:[function(require,module,exports){
+var baseSetData = require('./baseSetData'),
+    isNative = require('../lang/isNative'),
+    support = require('../support');
+
+/** Used to detect named functions. */
+var reFuncName = /^\s*function[ \n\r\t]+\w/;
+
+/** Used to detect functions containing a `this` reference. */
+var reThis = /\bthis\b/;
+
+/** Used to resolve the decompiled source of functions. */
+var fnToString = Function.prototype.toString;
+
+/**
+ * Checks if `func` is eligible for `this` binding.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is eligible, else `false`.
+ */
+function isBindable(func) {
+  var result = !(support.funcNames ? func.name : support.funcDecomp);
+
+  if (!result) {
+    var source = fnToString.call(func);
+    if (!support.funcNames) {
+      result = !reFuncName.test(source);
+    }
+    if (!result) {
+      // Check if `func` references the `this` keyword and store the result.
+      result = reThis.test(source) || isNative(func);
+      baseSetData(func, result);
+    }
+  }
+  return result;
+}
+
+module.exports = isBindable;
+
+},{"../lang/isNative":287,"../support":301,"./baseSetData":237}],267:[function(require,module,exports){
+/**
+ * Used as the maximum length of an array-like value.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer)
+ * for more details.
+ */
+var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+  value = +value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return value > -1 && value % 1 == 0 && value < length;
+}
+
+module.exports = isIndex;
+
+},{}],268:[function(require,module,exports){
+var isIndex = require('./isIndex'),
+    isLength = require('./isLength'),
+    isObject = require('../lang/isObject');
+
+/**
+ * Checks if the provided arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
+ */
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == 'number') {
+    var length = object.length,
+        prereq = isLength(length) && isIndex(index, length);
+  } else {
+    prereq = type == 'string' && index in object;
+  }
+  if (prereq) {
+    var other = object[index];
+    return value === value ? value === other : other !== other;
+  }
+  return false;
+}
+
+module.exports = isIterateeCall;
+
+},{"../lang/isObject":289,"./isIndex":267,"./isLength":269}],269:[function(require,module,exports){
+/**
+ * Used as the maximum length of an array-like value.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer)
+ * for more details.
+ */
+var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This function is based on ES `ToLength`. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength)
+ * for more details.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ */
+function isLength(value) {
+  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+module.exports = isLength;
+
+},{}],270:[function(require,module,exports){
+/**
+ * Checks if `value` is object-like.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ */
+function isObjectLike(value) {
+  return (value && typeof value == 'object') || false;
+}
+
+module.exports = isObjectLike;
+
+},{}],271:[function(require,module,exports){
+var isObject = require('../lang/isObject');
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ *  equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+  return value === value && (value === 0 ? ((1 / value) > 0) : !isObject(value));
+}
+
+module.exports = isStrictComparable;
+
+},{"../lang/isObject":289}],272:[function(require,module,exports){
+var arrayCopy = require('./arrayCopy'),
+    composeArgs = require('./composeArgs'),
+    composeArgsRight = require('./composeArgsRight'),
+    replaceHolders = require('./replaceHolders');
+
+/** Used to compose bitmasks for wrapper metadata. */
+var BIND_FLAG = 1,
+    BIND_KEY_FLAG = 2,
+    CURRY_BOUND_FLAG = 4,
+    CURRY_RIGHT_FLAG = 16,
+    REARG_FLAG = 128,
+    ARY_FLAG = 256;
+
+/** Used as the internal argument placeholder. */
+var PLACEHOLDER = '__lodash_placeholder__';
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMin = Math.min;
+
+/**
+ * Merges the function metadata of `source` into `data`.
+ *
+ * Merging metadata reduces the number of wrappers required to invoke a function.
+ * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
+ * may be applied regardless of execution order. Methods like `_.ary` and `_.rearg`
+ * augment function arguments, making the order in which they are executed important,
+ * preventing the merging of metadata. However, we make an exception for a safe
+ * common case where curried functions have `_.ary` and or `_.rearg` applied.
+ *
+ * @private
+ * @param {Array} data The destination metadata.
+ * @param {Array} source The source metadata.
+ * @returns {Array} Returns `data`.
+ */
+function mergeData(data, source) {
+  var bitmask = data[1],
+      srcBitmask = source[1],
+      newBitmask = bitmask | srcBitmask;
+
+  var arityFlags = ARY_FLAG | REARG_FLAG,
+      bindFlags = BIND_FLAG | BIND_KEY_FLAG,
+      comboFlags = arityFlags | bindFlags | CURRY_BOUND_FLAG | CURRY_RIGHT_FLAG;
+
+  var isAry = bitmask & ARY_FLAG && !(srcBitmask & ARY_FLAG),
+      isRearg = bitmask & REARG_FLAG && !(srcBitmask & REARG_FLAG),
+      argPos = (isRearg ? data : source)[7],
+      ary = (isAry ? data : source)[8];
+
+  var isCommon = !(bitmask >= REARG_FLAG && srcBitmask > bindFlags) &&
+    !(bitmask > bindFlags && srcBitmask >= REARG_FLAG);
+
+  var isCombo = (newBitmask >= arityFlags && newBitmask <= comboFlags) &&
+    (bitmask < REARG_FLAG || ((isRearg || isAry) && argPos.length <= ary));
+
+  // Exit early if metadata can't be merged.
+  if (!(isCommon || isCombo)) {
+    return data;
+  }
+  // Use source `thisArg` if available.
+  if (srcBitmask & BIND_FLAG) {
+    data[2] = source[2];
+    // Set when currying a bound function.
+    newBitmask |= (bitmask & BIND_FLAG) ? 0 : CURRY_BOUND_FLAG;
+  }
+  // Compose partial arguments.
+  var value = source[3];
+  if (value) {
+    var partials = data[3];
+    data[3] = partials ? composeArgs(partials, value, source[4]) : arrayCopy(value);
+    data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : arrayCopy(source[4]);
+  }
+  // Compose partial right arguments.
+  value = source[5];
+  if (value) {
+    partials = data[5];
+    data[5] = partials ? composeArgsRight(partials, value, source[6]) : arrayCopy(value);
+    data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : arrayCopy(source[6]);
+  }
+  // Use source `argPos` if available.
+  value = source[7];
+  if (value) {
+    data[7] = arrayCopy(value);
+  }
+  // Use source `ary` if it's smaller.
+  if (srcBitmask & ARY_FLAG) {
+    data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
+  }
+  // Use source `arity` if one is not provided.
+  if (data[9] == null) {
+    data[9] = source[9];
+  }
+  // Use source `func` and merge bitmasks.
+  data[0] = source[0];
+  data[1] = newBitmask;
+
+  return data;
+}
+
+module.exports = mergeData;
+
+},{"./arrayCopy":208,"./composeArgs":248,"./composeArgsRight":249,"./replaceHolders":275}],273:[function(require,module,exports){
+(function (global){
+var isNative = require('../lang/isNative');
+
+/** Native method references. */
+var WeakMap = isNative(WeakMap = global.WeakMap) && WeakMap;
+
+/** Used to store function metadata. */
+var metaMap = WeakMap && new WeakMap;
+
+module.exports = metaMap;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../lang/isNative":287}],274:[function(require,module,exports){
+var arrayCopy = require('./arrayCopy'),
+    isIndex = require('./isIndex');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeMin = Math.min;
+
+/**
+ * Reorder `array` according to the specified indexes where the element at
+ * the first index is assigned as the first element, the element at
+ * the second index is assigned as the second element, and so on.
+ *
+ * @private
+ * @param {Array} array The array to reorder.
+ * @param {Array} indexes The arranged array indexes.
+ * @returns {Array} Returns `array`.
+ */
+function reorder(array, indexes) {
+  var arrLength = array.length,
+      length = nativeMin(indexes.length, arrLength),
+      oldArray = arrayCopy(array);
+
+  while (length--) {
+    var index = indexes[length];
+    array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
+  }
+  return array;
+}
+
+module.exports = reorder;
+
+},{"./arrayCopy":208,"./isIndex":267}],275:[function(require,module,exports){
+/** Used as the internal argument placeholder. */
+var PLACEHOLDER = '__lodash_placeholder__';
+
+/**
+ * Replaces all `placeholder` elements in `array` with an internal placeholder
+ * and returns an array of their indexes.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {*} placeholder The placeholder to replace.
+ * @returns {Array} Returns the new array of placeholder indexes.
+ */
+function replaceHolders(array, placeholder) {
+  var index = -1,
+      length = array.length,
+      resIndex = -1,
+      result = [];
+
+  while (++index < length) {
+    if (array[index] === placeholder) {
+      array[index] = PLACEHOLDER;
+      result[++resIndex] = index;
+    }
+  }
+  return result;
+}
+
+module.exports = replaceHolders;
+
+},{}],276:[function(require,module,exports){
+var baseSetData = require('./baseSetData'),
+    now = require('../date/now');
+
+/** Used to detect when a function becomes hot. */
+var HOT_COUNT = 150,
+    HOT_SPAN = 16;
+
+/**
+ * Sets metadata for `func`.
+ *
+ * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
+ * period of time, it will trip its breaker and transition to an identity function
+ * to avoid garbage collection pauses in V8. See [V8 issue 2070](https://code.google.com/p/v8/issues/detail?id=2070)
+ * for more details.
+ *
+ * @private
+ * @param {Function} func The function to associate metadata with.
+ * @param {*} data The metadata.
+ * @returns {Function} Returns `func`.
+ */
+var setData = (function() {
+  var count = 0,
+      lastCalled = 0;
+
+  return function(key, value) {
+    var stamp = now(),
+        remaining = HOT_SPAN - (stamp - lastCalled);
+
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return key;
+      }
+    } else {
+      count = 0;
+    }
+    return baseSetData(key, value);
+  };
+}());
+
+module.exports = setData;
+
+},{"../date/now":205,"./baseSetData":237}],277:[function(require,module,exports){
+var isArguments = require('../lang/isArguments'),
+    isArray = require('../lang/isArray'),
+    isIndex = require('./isIndex'),
+    isLength = require('./isLength'),
+    keysIn = require('../object/keysIn'),
+    support = require('../support');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A fallback implementation of `Object.keys` which creates an array of the
+ * own enumerable property names of `object`.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the array of property names.
+ */
+function shimKeys(object) {
+  var props = keysIn(object),
+      propsLength = props.length,
+      length = propsLength && object.length;
+
+  var allowIndexes = length && isLength(length) &&
+    (isArray(object) || (support.nonEnumArgs && isArguments(object)));
+
+  var index = -1,
+      result = [];
+
+  while (++index < propsLength) {
+    var key = props[index];
+    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = shimKeys;
+
+},{"../lang/isArguments":282,"../lang/isArray":283,"../object/keysIn":298,"../support":301,"./isIndex":267,"./isLength":269}],278:[function(require,module,exports){
+/**
+ * An implementation of `_.uniq` optimized for sorted arrays without support
+ * for callback shorthands and `this` binding.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The function invoked per iteration.
+ * @returns {Array} Returns the new duplicate-value-free array.
+ */
+function sortedUniq(array, iteratee) {
+  var seen,
+      index = -1,
+      length = array.length,
+      resIndex = -1,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index],
+        computed = iteratee ? iteratee(value, index, array) : value;
+
+    if (!index || seen !== computed) {
+      seen = computed;
+      result[++resIndex] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = sortedUniq;
+
+},{}],279:[function(require,module,exports){
+var isObject = require('../lang/isObject');
+
+/**
+ * Converts `value` to an object if it is not one.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {Object} Returns the object.
+ */
+function toObject(value) {
+  return isObject(value) ? value : Object(value);
+}
+
+module.exports = toObject;
+
+},{"../lang/isObject":289}],280:[function(require,module,exports){
+var baseClone = require('../internal/baseClone'),
+    bindCallback = require('../internal/bindCallback'),
+    isIterateeCall = require('../internal/isIterateeCall');
+
+/**
+ * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned,
+ * otherwise they are assigned by reference. If `customizer` is provided it is
+ * invoked to produce the cloned values. If `customizer` returns `undefined`
+ * cloning is handled by the method instead. The `customizer` is bound to
+ * `thisArg` and invoked with two argument; (value [, index|key, object]).
+ *
+ * **Note:** This method is loosely based on the structured clone algorithm.
+ * The enumerable properties of `arguments` objects and objects created by
+ * constructors other than `Object` are cloned to plain `Object` objects. An
+ * empty object is returned for uncloneable values such as functions, DOM nodes,
+ * Maps, Sets, and WeakMaps. See the [HTML5 specification](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @param {Function} [customizer] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `customizer`.
+ * @returns {*} Returns the cloned value.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney' },
+ *   { 'user': 'fred' }
+ * ];
+ *
+ * var shallow = _.clone(users);
+ * shallow[0] === users[0];
+ * // => true
+ *
+ * var deep = _.clone(users, true);
+ * deep[0] === users[0];
+ * // => false
+ *
+ * // using a customizer callback
+ * var el = _.clone(document.body, function(value) {
+ *   if (_.isElement(value)) {
+ *     return value.cloneNode(false);
+ *   }
+ * });
+ *
+ * el === document.body
+ * // => false
+ * el.nodeName
+ * // => BODY
+ * el.childNodes.length;
+ * // => 0
+ */
+function clone(value, isDeep, customizer, thisArg) {
+  if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) {
+    isDeep = false;
+  }
+  else if (typeof isDeep == 'function') {
+    thisArg = customizer;
+    customizer = isDeep;
+    isDeep = false;
+  }
+  customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 1);
+  return baseClone(value, isDeep, customizer);
+}
+
+module.exports = clone;
+
+},{"../internal/baseClone":216,"../internal/bindCallback":243,"../internal/isIterateeCall":268}],281:[function(require,module,exports){
+var baseClone = require('../internal/baseClone'),
+    bindCallback = require('../internal/bindCallback');
+
+/**
+ * Creates a deep clone of `value`. If `customizer` is provided it is invoked
+ * to produce the cloned values. If `customizer` returns `undefined` cloning
+ * is handled by the method instead. The `customizer` is bound to `thisArg`
+ * and invoked with two argument; (value [, index|key, object]).
+ *
+ * **Note:** This method is loosely based on the structured clone algorithm.
+ * The enumerable properties of `arguments` objects and objects created by
+ * constructors other than `Object` are cloned to plain `Object` objects. An
+ * empty object is returned for uncloneable values such as functions, DOM nodes,
+ * Maps, Sets, and WeakMaps. See the [HTML5 specification](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to deep clone.
+ * @param {Function} [customizer] The function to customize cloning values.
+ * @param {*} [thisArg] The `this` binding of `customizer`.
+ * @returns {*} Returns the deep cloned value.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney' },
+ *   { 'user': 'fred' }
+ * ];
+ *
+ * var deep = _.cloneDeep(users);
+ * deep[0] === users[0];
+ * // => false
+ *
+ * // using a customizer callback
+ * var el = _.cloneDeep(document.body, function(value) {
+ *   if (_.isElement(value)) {
+ *     return value.cloneNode(true);
+ *   }
+ * });
+ *
+ * el === document.body
+ * // => false
+ * el.nodeName
+ * // => BODY
+ * el.childNodes.length;
+ * // => 20
+ */
+function cloneDeep(value, customizer, thisArg) {
+  customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 1);
+  return baseClone(value, true, customizer);
+}
+
+module.exports = cloneDeep;
+
+},{"../internal/baseClone":216,"../internal/bindCallback":243}],282:[function(require,module,exports){
+var isLength = require('../internal/isLength'),
+    isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+function isArguments(value) {
+  var length = isObjectLike(value) ? value.length : undefined;
+  return (isLength(length) && objToString.call(value) == argsTag) || false;
+}
+
+module.exports = isArguments;
+
+},{"../internal/isLength":269,"../internal/isObjectLike":270}],283:[function(require,module,exports){
+var isLength = require('../internal/isLength'),
+    isNative = require('./isNative'),
+    isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var arrayTag = '[object Array]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray;
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(function() { return arguments; }());
+ * // => false
+ */
+var isArray = nativeIsArray || function(value) {
+  return (isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag) || false;
+};
+
+module.exports = isArray;
+
+},{"../internal/isLength":269,"../internal/isObjectLike":270,"./isNative":287}],284:[function(require,module,exports){
+var isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a boolean primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isBoolean(false);
+ * // => true
+ *
+ * _.isBoolean(null);
+ * // => false
+ */
+function isBoolean(value) {
+  return (value === true || value === false || isObjectLike(value) && objToString.call(value) == boolTag) || false;
+}
+
+module.exports = isBoolean;
+
+},{"../internal/isObjectLike":270}],285:[function(require,module,exports){
+var isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isFunction = require('./isFunction'),
+    isLength = require('../internal/isLength'),
+    isObjectLike = require('../internal/isObjectLike'),
+    isString = require('./isString'),
+    keys = require('../object/keys');
+
+/**
+ * Checks if a value is empty. A value is considered empty unless it is an
+ * `arguments` object, array, string, or jQuery-like collection with a length
+ * greater than `0` or an object with own enumerable properties.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {Array|Object|string} value The value to inspect.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  var length = value.length;
+  if (isLength(length) && (isArray(value) || isString(value) || isArguments(value) ||
+      (isObjectLike(value) && isFunction(value.splice)))) {
+    return !length;
+  }
+  return !keys(value).length;
+}
+
+module.exports = isEmpty;
+
+},{"../internal/isLength":269,"../internal/isObjectLike":270,"../object/keys":297,"./isArguments":282,"./isArray":283,"./isFunction":286,"./isString":291}],286:[function(require,module,exports){
+(function (global){
+var baseIsFunction = require('../internal/baseIsFunction'),
+    isNative = require('./isNative');
+
+/** `Object#toString` result references. */
+var funcTag = '[object Function]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/** Native method references. */
+var Uint8Array = isNative(Uint8Array = global.Uint8Array) && Uint8Array;
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+var isFunction = !(baseIsFunction(/x/) || (Uint8Array && !baseIsFunction(Uint8Array))) ? baseIsFunction : function(value) {
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in older versions of Chrome and Safari which return 'function' for regexes
+  // and Safari 8 equivalents which return 'object' for typed array constructors.
+  return objToString.call(value) == funcTag;
+};
+
+module.exports = isFunction;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../internal/baseIsFunction":230,"./isNative":287}],287:[function(require,module,exports){
+var escapeRegExp = require('../string/escapeRegExp'),
+    isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var funcTag = '[object Function]';
+
+/** Used to detect host constructors (Safari > 5). */
+var reHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var fnToString = Function.prototype.toString;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reNative = RegExp('^' +
+  escapeRegExp(objToString)
+  .replace(/toString|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/**
+ * Checks if `value` is a native function.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
+ * @example
+ *
+ * _.isNative(Array.prototype.push);
+ * // => true
+ *
+ * _.isNative(_);
+ * // => false
+ */
+function isNative(value) {
+  if (value == null) {
+    return false;
+  }
+  if (objToString.call(value) == funcTag) {
+    return reNative.test(fnToString.call(value));
+  }
+  return (isObjectLike(value) && reHostCtor.test(value)) || false;
+}
+
+module.exports = isNative;
+
+},{"../internal/isObjectLike":270,"../string/escapeRegExp":300}],288:[function(require,module,exports){
+var isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var numberTag = '[object Number]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a `Number` primitive or object.
+ *
+ * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified
+ * as numbers, use the `_.isFinite` method.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isNumber(8.4);
+ * // => true
+ *
+ * _.isNumber(NaN);
+ * // => true
+ *
+ * _.isNumber('8.4');
+ * // => false
+ */
+function isNumber(value) {
+  return typeof value == 'number' || (isObjectLike(value) && objToString.call(value) == numberTag) || false;
+}
+
+module.exports = isNumber;
+
+},{"../internal/isObjectLike":270}],289:[function(require,module,exports){
+/**
+ * Checks if `value` is the language type of `Object`.
+ * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * **Note:** See the [ES5 spec](https://es5.github.io/#x8) for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(1);
+ * // => false
+ */
+function isObject(value) {
+  // Avoid a V8 JIT bug in Chrome 19-20.
+  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
+  var type = typeof value;
+  return type == 'function' || (value && type == 'object') || false;
+}
+
+module.exports = isObject;
+
+},{}],290:[function(require,module,exports){
+var isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var regexpTag = '[object RegExp]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a `RegExp` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isRegExp(/abc/);
+ * // => true
+ *
+ * _.isRegExp('/abc/');
+ * // => false
+ */
+function isRegExp(value) {
+  return (isObjectLike(value) && objToString.call(value) == regexpTag) || false;
+}
+
+module.exports = isRegExp;
+
+},{"../internal/isObjectLike":270}],291:[function(require,module,exports){
+var isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var stringTag = '[object String]';
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */
+function isString(value) {
+  return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag) || false;
+}
+
+module.exports = isString;
+
+},{"../internal/isObjectLike":270}],292:[function(require,module,exports){
+var isLength = require('../internal/isLength'),
+    isObjectLike = require('../internal/isObjectLike');
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+typedArrayTags[dateTag] = typedArrayTags[errorTag] =
+typedArrayTags[funcTag] = typedArrayTags[mapTag] =
+typedArrayTags[numberTag] = typedArrayTags[objectTag] =
+typedArrayTags[regexpTag] = typedArrayTags[setTag] =
+typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the `toStringTag` of values.
+ * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
+ * for more details.
+ */
+var objToString = objectProto.toString;
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+function isTypedArray(value) {
+  return (isObjectLike(value) && isLength(value.length) && typedArrayTags[objToString.call(value)]) || false;
+}
+
+module.exports = isTypedArray;
+
+},{"../internal/isLength":269,"../internal/isObjectLike":270}],293:[function(require,module,exports){
+var baseAssign = require('../internal/baseAssign'),
+    createAssigner = require('../internal/createAssigner');
+
+/**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object. Subsequent sources overwrite property assignments of previous sources.
+ * If `customizer` is provided it is invoked to produce the assigned values.
+ * The `customizer` is bound to `thisArg` and invoked with five arguments;
+ * (objectValue, sourceValue, key, object, source).
+ *
+ * @static
+ * @memberOf _
+ * @alias extend
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @param {Function} [customizer] The function to customize assigning values.
+ * @param {*} [thisArg] The `this` binding of `customizer`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });
+ * // => { 'user': 'fred', 'age': 40 }
+ *
+ * // using a customizer callback
+ * var defaults = _.partialRight(_.assign, function(value, other) {
+ *   return typeof value == 'undefined' ? other : value;
+ * });
+ *
+ * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
+ * // => { 'user': 'barney', 'age': 36 }
+ */
+var assign = createAssigner(baseAssign);
+
+module.exports = assign;
+
+},{"../internal/baseAssign":214,"../internal/createAssigner":251}],294:[function(require,module,exports){
+var arrayCopy = require('../internal/arrayCopy'),
+    assign = require('./assign'),
+    assignDefaults = require('../internal/assignDefaults');
+
+/**
+ * Assigns own enumerable properties of source object(s) to the destination
+ * object for all destination properties that resolve to `undefined`. Once a
+ * property is set, additional defaults of the same property are ignored.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
+ * // => { 'user': 'barney', 'age': 36 }
+ */
+function defaults(object) {
+  if (object == null) {
+    return object;
+  }
+  var args = arrayCopy(arguments);
+  args.push(assignDefaults);
+  return assign.apply(undefined, args);
+}
+
+module.exports = defaults;
+
+},{"../internal/arrayCopy":208,"../internal/assignDefaults":213,"./assign":293}],295:[function(require,module,exports){
+module.exports = require('./assign');
+
+},{"./assign":293}],296:[function(require,module,exports){
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if `key` exists as a direct property of `object` instead of an
+ * inherited property.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @param {string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` is a direct property, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2, 'c': 3 };
+ *
+ * _.has(object, 'b');
+ * // => true
+ */
+function has(object, key) {
+  return object ? hasOwnProperty.call(object, key) : false;
+}
+
+module.exports = has;
+
+},{}],297:[function(require,module,exports){
+var isLength = require('../internal/isLength'),
+    isNative = require('../lang/isNative'),
+    isObject = require('../lang/isObject'),
+    shimKeys = require('../internal/shimKeys');
+
+/* Native method references for those with the same name as other `lodash` methods. */
+var nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys;
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+var keys = !nativeKeys ? shimKeys : function(object) {
+  if (object) {
+    var Ctor = object.constructor,
+        length = object.length;
+  }
+  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
+     (typeof object != 'function' && (length && isLength(length)))) {
+    return shimKeys(object);
+  }
+  return isObject(object) ? nativeKeys(object) : [];
+};
+
+module.exports = keys;
+
+},{"../internal/isLength":269,"../internal/shimKeys":277,"../lang/isNative":287,"../lang/isObject":289}],298:[function(require,module,exports){
+var isArguments = require('../lang/isArguments'),
+    isArray = require('../lang/isArray'),
+    isIndex = require('../internal/isIndex'),
+    isLength = require('../internal/isLength'),
+    isObject = require('../lang/isObject'),
+    support = require('../support');
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+  if (object == null) {
+    return [];
+  }
+  if (!isObject(object)) {
+    object = Object(object);
+  }
+  var length = object.length;
+  length = (length && isLength(length) &&
+    (isArray(object) || (support.nonEnumArgs && isArguments(object))) && length) || 0;
+
+  var Ctor = object.constructor,
+      index = -1,
+      isProto = typeof Ctor == 'function' && Ctor.prototype === object,
+      result = Array(length),
+      skipIndexes = length > 0;
+
+  while (++index < length) {
+    result[index] = (index + '');
+  }
+  for (var key in object) {
+    if (!(skipIndexes && isIndex(key, length)) &&
+        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = keysIn;
+
+},{"../internal/isIndex":267,"../internal/isLength":269,"../lang/isArguments":282,"../lang/isArray":283,"../lang/isObject":289,"../support":301}],299:[function(require,module,exports){
+var baseValues = require('../internal/baseValues'),
+    keys = require('./keys');
+
+/**
+ * Creates an array of the own enumerable property values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.values(new Foo);
+ * // => [1, 2] (iteration order is not guaranteed)
+ *
+ * _.values('hi');
+ * // => ['h', 'i']
+ */
+function values(object) {
+  return baseValues(object, keys(object));
+}
+
+module.exports = values;
+
+},{"../internal/baseValues":242,"./keys":297}],300:[function(require,module,exports){
+var baseToString = require('../internal/baseToString');
+
+/**
+ * Used to match `RegExp` special characters.
+ * See this [article on `RegExp` characters](http://www.regular-expressions.info/characters.html#special)
+ * for more details.
+ */
+var reRegExpChars = /[.*+?^${}()|[\]\/\\]/g,
+    reHasRegExpChars = RegExp(reRegExpChars.source);
+
+/**
+ * Escapes the `RegExp` special characters "\", "^", "$", ".", "|", "?", "*",
+ * "+", "(", ")", "[", "]", "{" and "}" in `string`.
+ *
+ * @static
+ * @memberOf _
+ * @category String
+ * @param {string} [string=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escapeRegExp('[lodash](https://lodash.com/)');
+ * // => '\[lodash\]\(https://lodash\.com/\)'
+ */
+function escapeRegExp(string) {
+  string = baseToString(string);
+  return (string && reHasRegExpChars.test(string))
+    ? string.replace(reRegExpChars, '\\$&')
+    : string;
+}
+
+module.exports = escapeRegExp;
+
+},{"../internal/baseToString":240}],301:[function(require,module,exports){
+(function (global){
+var isNative = require('./lang/isNative');
+
+/** Used to detect functions containing a `this` reference. */
+var reThis = /\bthis\b/;
+
+/** Used for native method references. */
+var objectProto = Object.prototype;
+
+/** Used to detect DOM support. */
+var document = (document = global.window) && document.document;
+
+/** Native method references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/**
+ * An object environment feature flags.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+var support = {};
+
+(function(x) {
+
+  /**
+   * Detect if functions can be decompiled by `Function#toString`
+   * (all but Firefox OS certified apps, older Opera mobile browsers, and
+   * the PlayStation 3; forced `false` for Windows 8 apps).
+   *
+   * @memberOf _.support
+   * @type boolean
+   */
+  support.funcDecomp = !isNative(global.WinRTError) && reThis.test(function() { return this; });
+
+  /**
+   * Detect if `Function#name` is supported (all but IE).
+   *
+   * @memberOf _.support
+   * @type boolean
+   */
+  support.funcNames = typeof Function.name == 'string';
+
+  /**
+   * Detect if the DOM is supported.
+   *
+   * @memberOf _.support
+   * @type boolean
+   */
+  try {
+    support.dom = document.createDocumentFragment().nodeType === 11;
+  } catch(e) {
+    support.dom = false;
+  }
+
+  /**
+   * Detect if `arguments` object indexes are non-enumerable.
+   *
+   * In Firefox < 4, IE < 9, PhantomJS, and Safari < 5.1 `arguments` object
+   * indexes are non-enumerable. Chrome < 25 and Node.js < 0.11.0 treat
+   * `arguments` object indexes as non-enumerable and fail `hasOwnProperty`
+   * checks for indexes that exceed their function's formal parameters with
+   * associated values of `0`.
+   *
+   * @memberOf _.support
+   * @type boolean
+   */
+  try {
+    support.nonEnumArgs = !propertyIsEnumerable.call(arguments, 1);
+  } catch(e) {
+    support.nonEnumArgs = true;
+  }
+}(0, 0));
+
+module.exports = support;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./lang/isNative":287}],302:[function(require,module,exports){
+/**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utility
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var object = { 'user': 'fred' };
+ * var getter = _.constant(object);
+ *
+ * getter() === object;
+ * // => true
+ */
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+
+module.exports = constant;
+
+},{}],303:[function(require,module,exports){
+/**
+ * This method returns the first argument provided to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utility
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'user': 'fred' };
+ *
+ * _.identity(object) === object;
+ * // => true
+ */
+function identity(value) {
+  return value;
+}
+
+module.exports = identity;
+
+},{}],304:[function(require,module,exports){
+/**
+ * A no-operation function which returns `undefined` regardless of the
+ * arguments it receives.
+ *
+ * @static
+ * @memberOf _
+ * @category Utility
+ * @example
+ *
+ * var object = { 'user': 'fred' };
+ *
+ * _.noop(object) === undefined;
+ * // => true
+ */
+function noop() {
+  // No operation performed.
+}
+
+module.exports = noop;
+
+},{}],305:[function(require,module,exports){
+"use strict";
+
+var originalObject = Object;
+var originalDefProp = Object.defineProperty;
+var originalCreate = Object.create;
+
+function defProp(obj, name, value) {
+  if (originalDefProp) try {
+    originalDefProp.call(originalObject, obj, name, { value: value });
+  } catch (definePropertyIsBrokenInIE8) {
+    obj[name] = value;
+  } else {
+    obj[name] = value;
+  }
+}
+
+// For functions that will be invoked using .call or .apply, we need to
+// define those methods on the function objects themselves, rather than
+// inheriting them from Function.prototype, so that a malicious or clumsy
+// third party cannot interfere with the functionality of this module by
+// redefining Function.prototype.call or .apply.
+function makeSafeToCall(fun) {
+  if (fun) {
+    defProp(fun, "call", fun.call);
+    defProp(fun, "apply", fun.apply);
+  }
+  return fun;
+}
+
+makeSafeToCall(originalDefProp);
+makeSafeToCall(originalCreate);
+
+var hasOwn = makeSafeToCall(Object.prototype.hasOwnProperty);
+var numToStr = makeSafeToCall(Number.prototype.toString);
+var strSlice = makeSafeToCall(String.prototype.slice);
+
+var cloner = function(){};
+function create(prototype) {
+  if (originalCreate) {
+    return originalCreate.call(originalObject, prototype);
+  }
+  cloner.prototype = prototype || null;
+  return new cloner;
+}
+
+var rand = Math.random;
+var uniqueKeys = create(null);
+
+function makeUniqueKey() {
+  // Collisions are highly unlikely, but this module is in the business of
+  // making guarantees rather than safe bets.
+  do var uniqueKey = internString(strSlice.call(numToStr.call(rand(), 36), 2));
+  while (hasOwn.call(uniqueKeys, uniqueKey));
+  return uniqueKeys[uniqueKey] = uniqueKey;
+}
+
+function internString(str) {
+  var obj = {};
+  obj[str] = true;
+  return Object.keys(obj)[0];
+}
+
+// External users might find this function useful, but it is not necessary
+// for the typical use of this module.
+defProp(exports, "makeUniqueKey", makeUniqueKey);
+
+// Object.getOwnPropertyNames is the only way to enumerate non-enumerable
+// properties, so if we wrap it to ignore our secret keys, there should be
+// no way (except guessing) to access those properties.
+var originalGetOPNs = Object.getOwnPropertyNames;
+Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
+  for (var names = originalGetOPNs(object),
+           src = 0,
+           dst = 0,
+           len = names.length;
+       src < len;
+       ++src) {
+    if (!hasOwn.call(uniqueKeys, names[src])) {
+      if (src > dst) {
+        names[dst] = names[src];
+      }
+      ++dst;
+    }
+  }
+  names.length = dst;
+  return names;
+};
+
+function defaultCreatorFn(object) {
+  return create(null);
+}
+
+function makeAccessor(secretCreatorFn) {
+  var brand = makeUniqueKey();
+  var passkey = create(null);
+
+  secretCreatorFn = secretCreatorFn || defaultCreatorFn;
+
+  function register(object) {
+    var secret; // Created lazily.
+
+    function vault(key, forget) {
+      // Only code that has access to the passkey can retrieve (or forget)
+      // the secret object.
+      if (key === passkey) {
+        return forget
+          ? secret = null
+          : secret || (secret = secretCreatorFn(object));
+      }
+    }
+
+    defProp(object, brand, vault);
+  }
+
+  function accessor(object) {
+    if (!hasOwn.call(object, brand))
+      register(object);
+    return object[brand](passkey);
+  }
+
+  accessor.forget = function(object) {
+    if (hasOwn.call(object, brand))
+      object[brand](passkey, true);
+  };
+
+  return accessor;
+}
+
+defProp(exports, "makeAccessor", makeAccessor);
+
+},{}],306:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var isArray = types.builtInTypes.array;
+var b = types.builders;
+var n = types.namedTypes;
+var leap = require("./leap");
+var meta = require("./meta");
+var util = require("./util");
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function Emitter(contextId) {
+  assert.ok(this instanceof Emitter);
+  n.Identifier.assert(contextId);
+
+  Object.defineProperties(this, {
+    // In order to make sure the context object does not collide with
+    // anything in the local scope, we might have to rename it, so we
+    // refer to it symbolically instead of just assuming that it will be
+    // called "context".
+    contextId: { value: contextId },
+
+    // An append-only list of Statements that grows each time this.emit is
+    // called.
+    listing: { value: [] },
+
+    // A sparse array whose keys correspond to locations in this.listing
+    // that have been marked as branch/jump targets.
+    marked: { value: [true] },
+
+    // The last location will be marked when this.getDispatchLoop is
+    // called.
+    finalLoc: { value: loc() },
+
+    // A list of all leap.TryEntry statements emitted.
+    tryEntries: { value: [] }
+  });
+
+  // The .leapManager property needs to be defined by a separate
+  // defineProperties call so that .finalLoc will be visible to the
+  // leap.LeapManager constructor.
+  Object.defineProperties(this, {
+    // Each time we evaluate the body of a loop, we tell this.leapManager
+    // to enter a nested loop context that determines the meaning of break
+    // and continue statements therein.
+    leapManager: { value: new leap.LeapManager(this) }
+  });
+}
+
+var Ep = Emitter.prototype;
+exports.Emitter = Emitter;
+
+// Offsets into this.listing that could be used as targets for branches or
+// jumps are represented as numeric Literal nodes. This representation has
+// the amazingly convenient benefit of allowing the exact value of the
+// location to be determined at any time, even after generating code that
+// refers to the location.
+function loc() {
+  return b.literal(-1);
+}
+
+// Sets the exact value of the given location to the offset of the next
+// Statement emitted.
+Ep.mark = function(loc) {
+  n.Literal.assert(loc);
+  var index = this.listing.length;
+  if (loc.value === -1) {
+    loc.value = index;
+  } else {
+    // Locations can be marked redundantly, but their values cannot change
+    // once set the first time.
+    assert.strictEqual(loc.value, index);
+  }
+  this.marked[index] = true;
+  return loc;
+};
+
+Ep.emit = function(node) {
+  if (n.Expression.check(node))
+    node = b.expressionStatement(node);
+  n.Statement.assert(node);
+  this.listing.push(node);
+};
+
+// Shorthand for emitting assignment statements. This will come in handy
+// for assignments to temporary variables.
+Ep.emitAssign = function(lhs, rhs) {
+  this.emit(this.assign(lhs, rhs));
+  return lhs;
+};
+
+// Shorthand for an assignment statement.
+Ep.assign = function(lhs, rhs) {
+  return b.expressionStatement(
+    b.assignmentExpression("=", lhs, rhs));
+};
+
+// Convenience function for generating expressions like context.next,
+// context.sent, and context.rval.
+Ep.contextProperty = function(name, computed) {
+  return b.memberExpression(
+    this.contextId,
+    computed ? b.literal(name) : b.identifier(name),
+    !!computed
+  );
+};
+
+var volatileContextPropertyNames = {
+  prev: true,
+  next: true,
+  sent: true,
+  rval: true
+};
+
+// A "volatile" context property is a MemberExpression like context.sent
+// that should probably be stored in a temporary variable when there's a
+// possibility the property will get overwritten.
+Ep.isVolatileContextProperty = function(expr) {
+  if (n.MemberExpression.check(expr)) {
+    if (expr.computed) {
+      // If it's a computed property such as context[couldBeAnything],
+      // assume the worst in terms of volatility.
+      return true;
+    }
+
+    if (n.Identifier.check(expr.object) &&
+        n.Identifier.check(expr.property) &&
+        expr.object.name === this.contextId.name &&
+        hasOwn.call(volatileContextPropertyNames,
+                    expr.property.name)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+// Shorthand for setting context.rval and jumping to `context.stop()`.
+Ep.stop = function(rval) {
+  if (rval) {
+    this.setReturnValue(rval);
+  }
+
+  this.jump(this.finalLoc);
+};
+
+Ep.setReturnValue = function(valuePath) {
+  n.Expression.assert(valuePath.value);
+
+  this.emitAssign(
+    this.contextProperty("rval"),
+    this.explodeExpression(valuePath)
+  );
+};
+
+Ep.clearPendingException = function(tryLoc, assignee) {
+  n.Literal.assert(tryLoc);
+
+  var catchCall = b.callExpression(
+    this.contextProperty("catch", true),
+    [tryLoc]
+  );
+
+  if (assignee) {
+    this.emitAssign(assignee, catchCall);
+  } else {
+    this.emit(catchCall);
+  }
+};
+
+// Emits code for an unconditional jump to the given location, even if the
+// exact value of the location is not yet known.
+Ep.jump = function(toLoc) {
+  this.emitAssign(this.contextProperty("next"), toLoc);
+  this.emit(b.breakStatement());
+};
+
+// Conditional jump.
+Ep.jumpIf = function(test, toLoc) {
+  n.Expression.assert(test);
+  n.Literal.assert(toLoc);
+
+  this.emit(b.ifStatement(
+    test,
+    b.blockStatement([
+      this.assign(this.contextProperty("next"), toLoc),
+      b.breakStatement()
+    ])
+  ));
+};
+
+// Conditional jump, with the condition negated.
+Ep.jumpIfNot = function(test, toLoc) {
+  n.Expression.assert(test);
+  n.Literal.assert(toLoc);
+
+  var negatedTest;
+  if (n.UnaryExpression.check(test) &&
+      test.operator === "!") {
+    // Avoid double negation.
+    negatedTest = test.argument;
+  } else {
+    negatedTest = b.unaryExpression("!", test);
+  }
+
+  this.emit(b.ifStatement(
+    negatedTest,
+    b.blockStatement([
+      this.assign(this.contextProperty("next"), toLoc),
+      b.breakStatement()
+    ])
+  ));
+};
+
+// Returns a unique MemberExpression that can be used to store and
+// retrieve temporary values. Since the object of the member expression is
+// the context object, which is presumed to coexist peacefully with all
+// other local variables, and since we just increment `nextTempId`
+// monotonically, uniqueness is assured.
+var nextTempId = 0;
+Ep.makeTempVar = function() {
+  return this.contextProperty("t" + nextTempId++);
+};
+
+Ep.getContextFunction = function(id) {
+  var func = b.functionExpression(
+    id || null/*Anonymous*/,
+    [this.contextId],
+    b.blockStatement([this.getDispatchLoop()]),
+    false, // Not a generator anymore!
+    false // Nor an expression.
+  );
+  func._aliasFunction = true;
+  return func;
+};
+
+// Turns this.listing into a loop of the form
+//
+//   while (1) switch (context.next) {
+//   case 0:
+//   ...
+//   case n:
+//     return context.stop();
+//   }
+//
+// Each marked location in this.listing will correspond to one generated
+// case statement.
+Ep.getDispatchLoop = function() {
+  var self = this;
+  var cases = [];
+  var current;
+
+  // If we encounter a break, continue, or return statement in a switch
+  // case, we can skip the rest of the statements until the next case.
+  var alreadyEnded = false;
+
+  self.listing.forEach(function(stmt, i) {
+    if (self.marked.hasOwnProperty(i)) {
+      cases.push(b.switchCase(
+        b.literal(i),
+        current = []));
+      alreadyEnded = false;
+    }
+
+    if (!alreadyEnded) {
+      current.push(stmt);
+      if (isSwitchCaseEnder(stmt))
+        alreadyEnded = true;
+    }
+  });
+
+  // Now that we know how many statements there will be in this.listing,
+  // we can finally resolve this.finalLoc.value.
+  this.finalLoc.value = this.listing.length;
+
+  cases.push(
+    b.switchCase(this.finalLoc, [
+      // Intentionally fall through to the "end" case...
+    ]),
+
+    // So that the runtime can jump to the final location without having
+    // to know its offset, we provide the "end" case as a synonym.
+    b.switchCase(b.literal("end"), [
+      // This will check/clear both context.thrown and context.rval.
+      b.returnStatement(
+        b.callExpression(this.contextProperty("stop"), [])
+      )
+    ])
+  );
+
+  return b.whileStatement(
+    b.literal(1),
+    b.switchStatement(
+      b.assignmentExpression(
+        "=",
+        this.contextProperty("prev"),
+        this.contextProperty("next")
+      ),
+      cases
+    )
+  );
+};
+
+// See comment above re: alreadyEnded.
+function isSwitchCaseEnder(stmt) {
+  return n.BreakStatement.check(stmt)
+      || n.ContinueStatement.check(stmt)
+      || n.ReturnStatement.check(stmt)
+      || n.ThrowStatement.check(stmt);
+}
+
+Ep.getTryLocsList = function() {
+  if (this.tryEntries.length === 0) {
+    // To avoid adding a needless [] to the majority of runtime.wrap
+    // argument lists, force the caller to handle this case specially.
+    return null;
+  }
+
+  var lastLocValue = 0;
+
+  return b.arrayExpression(
+    this.tryEntries.map(function(tryEntry) {
+      var thisLocValue = tryEntry.firstLoc.value;
+      assert.ok(thisLocValue >= lastLocValue, "try entries out of order");
+      lastLocValue = thisLocValue;
+
+      var ce = tryEntry.catchEntry;
+      var fe = tryEntry.finallyEntry;
+
+      var locs = [
+        tryEntry.firstLoc,
+        // The null here makes a hole in the array.
+        ce ? ce.firstLoc : null
+      ];
+
+      if (fe) {
+        locs[2] = fe.firstLoc;
+        locs[3] = fe.afterLoc;
+      }
+
+      return b.arrayExpression(locs);
+    })
+  );
+};
+
+// All side effects must be realized in order.
+
+// If any subexpression harbors a leap, all subexpressions must be
+// neutered of side effects.
+
+// No destructive modification of AST nodes.
+
+Ep.explode = function(path, ignoreResult) {
+  assert.ok(path instanceof types.NodePath);
+
+  var node = path.value;
+  var self = this;
+
+  n.Node.assert(node);
+
+  if (n.Statement.check(node))
+    return self.explodeStatement(path);
+
+  if (n.Expression.check(node))
+    return self.explodeExpression(path, ignoreResult);
+
+  if (n.Declaration.check(node))
+    throw getDeclError(node);
+
+  switch (node.type) {
+  case "Program":
+    return path.get("body").map(
+      self.explodeStatement,
+      self
+    );
+
+  case "VariableDeclarator":
+    throw getDeclError(node);
+
+  // These node types should be handled by their parent nodes
+  // (ObjectExpression, SwitchStatement, and TryStatement, respectively).
+  case "Property":
+  case "SwitchCase":
+  case "CatchClause":
+    throw new Error(
+      node.type + " nodes should be handled by their parents");
+
+  default:
+    throw new Error(
+      "unknown Node of type " +
+        JSON.stringify(node.type));
+  }
+};
+
+function getDeclError(node) {
+  return new Error(
+    "all declarations should have been transformed into " +
+    "assignments before the Exploder began its work: " +
+    JSON.stringify(node));
+}
+
+Ep.explodeStatement = function(path, labelId) {
+  assert.ok(path instanceof types.NodePath);
+
+  var stmt = path.value;
+  var self = this;
+
+  n.Statement.assert(stmt);
+
+  if (labelId) {
+    n.Identifier.assert(labelId);
+  } else {
+    labelId = null;
+  }
+
+  // Explode BlockStatement nodes even if they do not contain a yield,
+  // because we don't want or need the curly braces.
+  if (n.BlockStatement.check(stmt)) {
+    return path.get("body").each(
+      self.explodeStatement,
+      self
+    );
+  }
+
+  if (!meta.containsLeap(stmt)) {
+    // Technically we should be able to avoid emitting the statement
+    // altogether if !meta.hasSideEffects(stmt), but that leads to
+    // confusing generated code (for instance, `while (true) {}` just
+    // disappears) and is probably a more appropriate job for a dedicated
+    // dead code elimination pass.
+    self.emit(stmt);
+    return;
+  }
+
+  switch (stmt.type) {
+  case "ExpressionStatement":
+    self.explodeExpression(path.get("expression"), true);
+    break;
+
+  case "LabeledStatement":
+    var after = loc();
+
+    // Did you know you can break from any labeled block statement or
+    // control structure? Well, you can! Note: when a labeled loop is
+    // encountered, the leap.LabeledEntry created here will immediately
+    // enclose a leap.LoopEntry on the leap manager's stack, and both
+    // entries will have the same label. Though this works just fine, it
+    // may seem a bit redundant. In theory, we could check here to
+    // determine if stmt knows how to handle its own label; for example,
+    // stmt happens to be a WhileStatement and so we know it's going to
+    // establish its own LoopEntry when we explode it (below). Then this
+    // LabeledEntry would be unnecessary. Alternatively, we might be
+    // tempted not to pass stmt.label down into self.explodeStatement,
+    // because we've handled the label here, but that's a mistake because
+    // labeled loops may contain labeled continue statements, which is not
+    // something we can handle in this generic case. All in all, I think a
+    // little redundancy greatly simplifies the logic of this case, since
+    // it's clear that we handle all possible LabeledStatements correctly
+    // here, regardless of whether they interact with the leap manager
+    // themselves. Also remember that labels and break/continue-to-label
+    // statements are rare, and all of this logic happens at transform
+    // time, so it has no additional runtime cost.
+    self.leapManager.withEntry(
+      new leap.LabeledEntry(after, stmt.label),
+      function() {
+        self.explodeStatement(path.get("body"), stmt.label);
+      }
+    );
+
+    self.mark(after);
+
+    break;
+
+  case "WhileStatement":
+    var before = loc();
+    var after = loc();
+
+    self.mark(before);
+    self.jumpIfNot(self.explodeExpression(path.get("test")), after);
+    self.leapManager.withEntry(
+      new leap.LoopEntry(after, before, labelId),
+      function() { self.explodeStatement(path.get("body")); }
+    );
+    self.jump(before);
+    self.mark(after);
+
+    break;
+
+  case "DoWhileStatement":
+    var first = loc();
+    var test = loc();
+    var after = loc();
+
+    self.mark(first);
+    self.leapManager.withEntry(
+      new leap.LoopEntry(after, test, labelId),
+      function() { self.explode(path.get("body")); }
+    );
+    self.mark(test);
+    self.jumpIf(self.explodeExpression(path.get("test")), first);
+    self.mark(after);
+
+    break;
+
+  case "ForStatement":
+    var head = loc();
+    var update = loc();
+    var after = loc();
+
+    if (stmt.init) {
+      // We pass true here to indicate that if stmt.init is an expression
+      // then we do not care about its result.
+      self.explode(path.get("init"), true);
+    }
+
+    self.mark(head);
+
+    if (stmt.test) {
+      self.jumpIfNot(self.explodeExpression(path.get("test")), after);
+    } else {
+      // No test means continue unconditionally.
+    }
+
+    self.leapManager.withEntry(
+      new leap.LoopEntry(after, update, labelId),
+      function() { self.explodeStatement(path.get("body")); }
+    );
+
+    self.mark(update);
+
+    if (stmt.update) {
+      // We pass true here to indicate that if stmt.update is an
+      // expression then we do not care about its result.
+      self.explode(path.get("update"), true);
+    }
+
+    self.jump(head);
+
+    self.mark(after);
+
+    break;
+
+  case "ForInStatement":
+    n.Identifier.assert(stmt.left);
+
+    var head = loc();
+    var after = loc();
+
+    var keyIterNextFn = self.makeTempVar();
+    self.emitAssign(
+      keyIterNextFn,
+      b.callExpression(
+        util.runtimeProperty("keys"),
+        [self.explodeExpression(path.get("right"))]
+      )
+    );
+
+    self.mark(head);
+
+    var keyInfoTmpVar = self.makeTempVar();
+    self.jumpIf(
+      b.memberExpression(
+        b.assignmentExpression(
+          "=",
+          keyInfoTmpVar,
+          b.callExpression(keyIterNextFn, [])
+        ),
+        b.identifier("done"),
+        false
+      ),
+      after
+    );
+
+    self.emitAssign(
+      stmt.left,
+      b.memberExpression(
+        keyInfoTmpVar,
+        b.identifier("value"),
+        false
+      )
+    );
+
+    self.leapManager.withEntry(
+      new leap.LoopEntry(after, head, labelId),
+      function() { self.explodeStatement(path.get("body")); }
+    );
+
+    self.jump(head);
+
+    self.mark(after);
+
+    break;
+
+  case "BreakStatement":
+    self.emitAbruptCompletion({
+      type: "break",
+      target: self.leapManager.getBreakLoc(stmt.label)
+    });
+
+    break;
+
+  case "ContinueStatement":
+    self.emitAbruptCompletion({
+      type: "continue",
+      target: self.leapManager.getContinueLoc(stmt.label)
+    });
+
+    break;
+
+  case "SwitchStatement":
+    // Always save the discriminant into a temporary variable in case the
+    // test expressions overwrite values like context.sent.
+    var disc = self.emitAssign(
+      self.makeTempVar(),
+      self.explodeExpression(path.get("discriminant"))
+    );
+
+    var after = loc();
+    var defaultLoc = loc();
+    var condition = defaultLoc;
+    var caseLocs = [];
+
+    // If there are no cases, .cases might be undefined.
+    var cases = stmt.cases || [];
+
+    for (var i = cases.length - 1; i >= 0; --i) {
+      var c = cases[i];
+      n.SwitchCase.assert(c);
+
+      if (c.test) {
+        condition = b.conditionalExpression(
+          b.binaryExpression("===", disc, c.test),
+          caseLocs[i] = loc(),
+          condition
+        );
+      } else {
+        caseLocs[i] = defaultLoc;
+      }
+    }
+
+    self.jump(self.explodeExpression(
+      new types.NodePath(condition, path, "discriminant")
+    ));
+
+    self.leapManager.withEntry(
+      new leap.SwitchEntry(after),
+      function() {
+        path.get("cases").each(function(casePath) {
+          var c = casePath.value;
+          var i = casePath.name;
+
+          self.mark(caseLocs[i]);
+
+          casePath.get("consequent").each(
+            self.explodeStatement,
+            self
+          );
+        });
+      }
+    );
+
+    self.mark(after);
+    if (defaultLoc.value === -1) {
+      self.mark(defaultLoc);
+      assert.strictEqual(after.value, defaultLoc.value);
+    }
+
+    break;
+
+  case "IfStatement":
+    var elseLoc = stmt.alternate && loc();
+    var after = loc();
+
+    self.jumpIfNot(
+      self.explodeExpression(path.get("test")),
+      elseLoc || after
+    );
+
+    self.explodeStatement(path.get("consequent"));
+
+    if (elseLoc) {
+      self.jump(after);
+      self.mark(elseLoc);
+      self.explodeStatement(path.get("alternate"));
+    }
+
+    self.mark(after);
+
+    break;
+
+  case "ReturnStatement":
+    self.emitAbruptCompletion({
+      type: "return",
+      value: self.explodeExpression(path.get("argument"))
+    });
+
+    break;
+
+  case "WithStatement":
+    throw new Error(
+      node.type + " not supported in generator functions.");
+
+  case "TryStatement":
+    var after = loc();
+
+    var handler = stmt.handler;
+    if (!handler && stmt.handlers) {
+      handler = stmt.handlers[0] || null;
+    }
+
+    var catchLoc = handler && loc();
+    var catchEntry = catchLoc && new leap.CatchEntry(
+      catchLoc,
+      handler.param
+    );
+
+    var finallyLoc = stmt.finalizer && loc();
+    var finallyEntry = finallyLoc &&
+      new leap.FinallyEntry(finallyLoc, after);
+
+    var tryEntry = new leap.TryEntry(
+      self.getUnmarkedCurrentLoc(),
+      catchEntry,
+      finallyEntry
+    );
+
+    self.tryEntries.push(tryEntry);
+    self.updateContextPrevLoc(tryEntry.firstLoc);
+
+    self.leapManager.withEntry(tryEntry, function() {
+      self.explodeStatement(path.get("block"));
+
+      if (catchLoc) {
+        if (finallyLoc) {
+          // If we have both a catch block and a finally block, then
+          // because we emit the catch block first, we need to jump over
+          // it to the finally block.
+          self.jump(finallyLoc);
+
+        } else {
+          // If there is no finally block, then we need to jump over the
+          // catch block to the fall-through location.
+          self.jump(after);
+        }
+
+        self.updateContextPrevLoc(self.mark(catchLoc));
+
+        var bodyPath = path.get("handler", "body");
+        var safeParam = self.makeTempVar();
+        self.clearPendingException(tryEntry.firstLoc, safeParam);
+
+        var catchScope = bodyPath.scope;
+        var catchParamName = handler.param.name;
+        n.CatchClause.assert(catchScope.node);
+        assert.strictEqual(catchScope.lookup(catchParamName), catchScope);
+
+        types.visit(bodyPath, {
+          visitIdentifier: function(path) {
+            if (util.isReference(path, catchParamName) &&
+                path.scope.lookup(catchParamName) === catchScope) {
+              return safeParam;
+            }
+
+            this.traverse(path);
+          },
+
+          visitFunction: function(path) {
+            if (path.scope.declares(catchParamName)) {
+              // Don't descend into nested scopes that shadow the catch
+              // parameter with their own declarations. This isn't
+              // logically necessary because of the path.scope.lookup we
+              // do in visitIdentifier, but it saves time.
+              return false;
+            }
+
+            this.traverse(path);
+          }
+        });
+
+        self.leapManager.withEntry(catchEntry, function() {
+          self.explodeStatement(bodyPath);
+        });
+      }
+
+      if (finallyLoc) {
+        self.updateContextPrevLoc(self.mark(finallyLoc));
+
+        self.leapManager.withEntry(finallyEntry, function() {
+          self.explodeStatement(path.get("finalizer"));
+        });
+
+        self.emit(b.returnStatement(b.callExpression(
+          self.contextProperty("finish"),
+          [finallyEntry.firstLoc]
+        )));
+      }
+    });
+
+    self.mark(after);
+
+    break;
+
+  case "ThrowStatement":
+    self.emit(b.throwStatement(
+      self.explodeExpression(path.get("argument"))
+    ));
+
+    break;
+
+  default:
+    throw new Error(
+      "unknown Statement of type " +
+        JSON.stringify(stmt.type));
+  }
+};
+
+Ep.emitAbruptCompletion = function(record) {
+  if (!isValidCompletion(record)) {
+    assert.ok(
+      false,
+      "invalid completion record: " +
+        JSON.stringify(record)
+    );
+  }
+
+  assert.notStrictEqual(
+    record.type, "normal",
+    "normal completions are not abrupt"
+  );
+
+  var abruptArgs = [b.literal(record.type)];
+
+  if (record.type === "break" ||
+      record.type === "continue") {
+    n.Literal.assert(record.target);
+    abruptArgs[1] = record.target;
+  } else if (record.type === "return" ||
+             record.type === "throw") {
+    if (record.value) {
+      n.Expression.assert(record.value);
+      abruptArgs[1] = record.value;
+    }
+  }
+
+  this.emit(
+    b.returnStatement(
+      b.callExpression(
+        this.contextProperty("abrupt"),
+        abruptArgs
+      )
+    )
+  );
+};
+
+function isValidCompletion(record) {
+  var type = record.type;
+
+  if (type === "normal") {
+    return !hasOwn.call(record, "target");
+  }
+
+  if (type === "break" ||
+      type === "continue") {
+    return !hasOwn.call(record, "value")
+        && n.Literal.check(record.target);
+  }
+
+  if (type === "return" ||
+      type === "throw") {
+    return hasOwn.call(record, "value")
+        && !hasOwn.call(record, "target");
+  }
+
+  return false;
+}
+
+
+// Not all offsets into emitter.listing are potential jump targets. For
+// example, execution typically falls into the beginning of a try block
+// without jumping directly there. This method returns the current offset
+// without marking it, so that a switch case will not necessarily be
+// generated for this offset (I say "not necessarily" because the same
+// location might end up being marked in the process of emitting other
+// statements). There's no logical harm in marking such locations as jump
+// targets, but minimizing the number of switch cases keeps the generated
+// code shorter.
+Ep.getUnmarkedCurrentLoc = function() {
+  return b.literal(this.listing.length);
+};
+
+// The context.prev property takes the value of context.next whenever we
+// evaluate the switch statement discriminant, which is generally good
+// enough for tracking the last location we jumped to, but sometimes
+// context.prev needs to be more precise, such as when we fall
+// successfully out of a try block and into a finally block without
+// jumping. This method exists to update context.prev to the freshest
+// available location. If we were implementing a full interpreter, we
+// would know the location of the current instruction with complete
+// precision at all times, but we don't have that luxury here, as it would
+// be costly and verbose to set context.prev before every statement.
+Ep.updateContextPrevLoc = function(loc) {
+  if (loc) {
+    n.Literal.assert(loc);
+
+    if (loc.value === -1) {
+      // If an uninitialized location literal was passed in, set its value
+      // to the current this.listing.length.
+      loc.value = this.listing.length;
+    } else {
+      // Otherwise assert that the location matches the current offset.
+      assert.strictEqual(loc.value, this.listing.length);
+    }
+
+  } else {
+    loc = this.getUnmarkedCurrentLoc();
+  }
+
+  // Make sure context.prev is up to date in case we fell into this try
+  // statement without jumping to it. TODO Consider avoiding this
+  // assignment when we know control must have jumped here.
+  this.emitAssign(this.contextProperty("prev"), loc);
+};
+
+Ep.explodeExpression = function(path, ignoreResult) {
+  assert.ok(path instanceof types.NodePath);
+
+  var expr = path.value;
+  if (expr) {
+    n.Expression.assert(expr);
+  } else {
+    return expr;
+  }
+
+  var self = this;
+  var result; // Used optionally by several cases below.
+
+  function finish(expr) {
+    n.Expression.assert(expr);
+    if (ignoreResult) {
+      self.emit(expr);
+    } else {
+      return expr;
+    }
+  }
+
+  // If the expression does not contain a leap, then we either emit the
+  // expression as a standalone statement or return it whole.
+  if (!meta.containsLeap(expr)) {
+    return finish(expr);
+  }
+
+  // If any child contains a leap (such as a yield or labeled continue or
+  // break statement), then any sibling subexpressions will almost
+  // certainly have to be exploded in order to maintain the order of their
+  // side effects relative to the leaping child(ren).
+  var hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
+
+  // In order to save the rest of explodeExpression from a combinatorial
+  // trainwreck of special cases, explodeViaTempVar is responsible for
+  // deciding when a subexpression needs to be "exploded," which is my
+  // very technical term for emitting the subexpression as an assignment
+  // to a temporary variable and the substituting the temporary variable
+  // for the original subexpression. Think of exploded view diagrams, not
+  // Michael Bay movies. The point of exploding subexpressions is to
+  // control the precise order in which the generated code realizes the
+  // side effects of those subexpressions.
+  function explodeViaTempVar(tempVar, childPath, ignoreChildResult) {
+    assert.ok(childPath instanceof types.NodePath);
+
+    assert.ok(
+      !ignoreChildResult || !tempVar,
+      "Ignoring the result of a child expression but forcing it to " +
+        "be assigned to a temporary variable?"
+    );
+
+    var result = self.explodeExpression(childPath, ignoreChildResult);
+
+    if (ignoreChildResult) {
+      // Side effects already emitted above.
+
+    } else if (tempVar || (hasLeapingChildren &&
+                           (self.isVolatileContextProperty(result) ||
+                            meta.hasSideEffects(result)))) {
+      // If tempVar was provided, then the result will always be assigned
+      // to it, even if the result does not otherwise need to be assigned
+      // to a temporary variable.  When no tempVar is provided, we have
+      // the flexibility to decide whether a temporary variable is really
+      // necessary.  In general, temporary assignment is required only
+      // when some other child contains a leap and the child in question
+      // is a context property like $ctx.sent that might get overwritten
+      // or an expression with side effects that need to occur in proper
+      // sequence relative to the leap.
+      result = self.emitAssign(
+        tempVar || self.makeTempVar(),
+        result
+      );
+    }
+    return result;
+  }
+
+  // If ignoreResult is true, then we must take full responsibility for
+  // emitting the expression with all its side effects, and we should not
+  // return a result.
+
+  switch (expr.type) {
+  case "MemberExpression":
+    return finish(b.memberExpression(
+      self.explodeExpression(path.get("object")),
+      expr.computed
+        ? explodeViaTempVar(null, path.get("property"))
+        : expr.property,
+      expr.computed
+    ));
+
+  case "CallExpression":
+    var oldCalleePath = path.get("callee");
+    var newCallee = self.explodeExpression(oldCalleePath);
+
+    // If the callee was not previously a MemberExpression, then the
+    // CallExpression was "unqualified," meaning its `this` object should
+    // be the global object. If the exploded expression has become a
+    // MemberExpression, then we need to force it to be unqualified by
+    // using the (0, object.property)(...) trick; otherwise, it will
+    // receive the object of the MemberExpression as its `this` object.
+    if (!n.MemberExpression.check(oldCalleePath.node) &&
+        n.MemberExpression.check(newCallee)) {
+      newCallee = b.sequenceExpression([
+        b.literal(0),
+        newCallee
+      ]);
+    }
+
+    return finish(b.callExpression(
+      newCallee,
+      path.get("arguments").map(function(argPath) {
+        return explodeViaTempVar(null, argPath);
+      })
+    ));
+
+  case "NewExpression":
+    return finish(b.newExpression(
+      explodeViaTempVar(null, path.get("callee")),
+      path.get("arguments").map(function(argPath) {
+        return explodeViaTempVar(null, argPath);
+      })
+    ));
+
+  case "ObjectExpression":
+    return finish(b.objectExpression(
+      path.get("properties").map(function(propPath) {
+        return b.property(
+          propPath.value.kind,
+          propPath.value.key,
+          explodeViaTempVar(null, propPath.get("value"))
+        );
+      })
+    ));
+
+  case "ArrayExpression":
+    return finish(b.arrayExpression(
+      path.get("elements").map(function(elemPath) {
+        return explodeViaTempVar(null, elemPath);
+      })
+    ));
+
+  case "SequenceExpression":
+    var lastIndex = expr.expressions.length - 1;
+
+    path.get("expressions").each(function(exprPath) {
+      if (exprPath.name === lastIndex) {
+        result = self.explodeExpression(exprPath, ignoreResult);
+      } else {
+        self.explodeExpression(exprPath, true);
+      }
+    });
+
+    return result;
+
+  case "LogicalExpression":
+    var after = loc();
+
+    if (!ignoreResult) {
+      result = self.makeTempVar();
+    }
+
+    var left = explodeViaTempVar(result, path.get("left"));
+
+    if (expr.operator === "&&") {
+      self.jumpIfNot(left, after);
+    } else {
+      assert.strictEqual(expr.operator, "||");
+      self.jumpIf(left, after);
+    }
+
+    explodeViaTempVar(result, path.get("right"), ignoreResult);
+
+    self.mark(after);
+
+    return result;
+
+  case "ConditionalExpression":
+    var elseLoc = loc();
+    var after = loc();
+    var test = self.explodeExpression(path.get("test"));
+
+    self.jumpIfNot(test, elseLoc);
+
+    if (!ignoreResult) {
+      result = self.makeTempVar();
+    }
+
+    explodeViaTempVar(result, path.get("consequent"), ignoreResult);
+    self.jump(after);
+
+    self.mark(elseLoc);
+    explodeViaTempVar(result, path.get("alternate"), ignoreResult);
+
+    self.mark(after);
+
+    return result;
+
+  case "UnaryExpression":
+    return finish(b.unaryExpression(
+      expr.operator,
+      // Can't (and don't need to) break up the syntax of the argument.
+      // Think about delete a[b].
+      self.explodeExpression(path.get("argument")),
+      !!expr.prefix
+    ));
+
+  case "BinaryExpression":
+    return finish(b.binaryExpression(
+      expr.operator,
+      explodeViaTempVar(null, path.get("left")),
+      explodeViaTempVar(null, path.get("right"))
+    ));
+
+  case "AssignmentExpression":
+    return finish(b.assignmentExpression(
+      expr.operator,
+      self.explodeExpression(path.get("left")),
+      self.explodeExpression(path.get("right"))
+    ));
+
+  case "UpdateExpression":
+    return finish(b.updateExpression(
+      expr.operator,
+      self.explodeExpression(path.get("argument")),
+      expr.prefix
+    ));
+
+  case "YieldExpression":
+    var after = loc();
+    var arg = expr.argument && self.explodeExpression(path.get("argument"));
+
+    if (arg && expr.delegate) {
+      var result = self.makeTempVar();
+
+      self.emit(b.returnStatement(b.callExpression(
+        self.contextProperty("delegateYield"), [
+          arg,
+          b.literal(result.property.name),
+          after
+        ]
+      )));
+
+      self.mark(after);
+
+      return result;
+    }
+
+    self.emitAssign(self.contextProperty("next"), after);
+    self.emit(b.returnStatement(arg || null));
+    self.mark(after);
+
+    return self.contextProperty("sent");
+
+  default:
+    throw new Error(
+      "unknown Expression of type " +
+        JSON.stringify(expr.type));
+  }
+};
+
+},{"./leap":308,"./meta":309,"./util":310,"assert":138,"ast-types":136}],307:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+// The hoist function takes a FunctionExpression or FunctionDeclaration
+// and replaces any Declaration nodes in its body with assignments, then
+// returns a VariableDeclaration containing just the names of the removed
+// declarations.
+exports.hoist = function(funPath) {
+  assert.ok(funPath instanceof types.NodePath);
+  n.Function.assert(funPath.value);
+
+  var vars = {};
+
+  function varDeclToExpr(vdec, includeIdentifiers) {
+    n.VariableDeclaration.assert(vdec);
+    var exprs = [];
+
+    vdec.declarations.forEach(function(dec) {
+      vars[dec.id.name] = dec.id;
+
+      if (dec.init) {
+        exprs.push(b.assignmentExpression(
+          "=", dec.id, dec.init
+        ));
+      } else if (includeIdentifiers) {
+        exprs.push(dec.id);
+      }
+    });
+
+    if (exprs.length === 0)
+      return null;
+
+    if (exprs.length === 1)
+      return exprs[0];
+
+    return b.sequenceExpression(exprs);
+  }
+
+  types.visit(funPath.get("body"), {
+    visitVariableDeclaration: function(path) {
+      var expr = varDeclToExpr(path.value, false);
+      if (expr === null) {
+        path.replace();
+      } else {
+        // We don't need to traverse this expression any further because
+        // there can't be any new declarations inside an expression.
+        return b.expressionStatement(expr);
+      }
+
+      // Since the original node has been either removed or replaced,
+      // avoid traversing it any further.
+      return false;
+    },
+
+    visitForStatement: function(path) {
+      var init = path.value.init;
+      if (n.VariableDeclaration.check(init)) {
+        path.get("init").replace(varDeclToExpr(init, false));
+      }
+      this.traverse(path);
+    },
+
+    visitForInStatement: function(path) {
+      var left = path.value.left;
+      if (n.VariableDeclaration.check(left)) {
+        path.get("left").replace(varDeclToExpr(left, true));
+      }
+      this.traverse(path);
+    },
+
+    visitFunctionDeclaration: function(path) {
+      var node = path.value;
+      vars[node.id.name] = node.id;
+
+      var parentNode = path.parent.node;
+      var assignment = b.expressionStatement(
+        b.assignmentExpression(
+          "=",
+          node.id,
+          b.functionExpression(
+            node.id,
+            node.params,
+            node.body,
+            node.generator,
+            node.expression
+          )
+        )
+      );
+
+      if (n.BlockStatement.check(path.parent.node)) {
+        // Insert the assignment form before the first statement in the
+        // enclosing block.
+        path.parent.get("body").unshift(assignment);
+
+        // Remove the function declaration now that we've inserted the
+        // equivalent assignment form at the beginning of the block.
+        path.replace();
+
+      } else {
+        // If the parent node is not a block statement, then we can just
+        // replace the declaration with the equivalent assignment form
+        // without worrying about hoisting it.
+        path.replace(assignment);
+      }
+
+      // Don't hoist variables out of inner functions.
+      return false;
+    },
+
+    visitFunctionExpression: function(path) {
+      // Don't descend into nested function expressions.
+      return false;
+    }
+  });
+
+  var paramNames = {};
+  funPath.get("params").each(function(paramPath) {
+    var param = paramPath.value;
+    if (n.Identifier.check(param)) {
+      paramNames[param.name] = param;
+    } else {
+      // Variables declared by destructuring parameter patterns will be
+      // harmlessly re-declared.
+    }
+  });
+
+  var declarations = [];
+
+  Object.keys(vars).forEach(function(name) {
+    if (!hasOwn.call(paramNames, name)) {
+      declarations.push(b.variableDeclarator(vars[name], null));
+    }
+  });
+
+  if (declarations.length === 0) {
+    return null; // Be sure to handle this case!
+  }
+
+  return b.variableDeclaration("var", declarations);
+};
+
+},{"assert":138,"ast-types":136}],308:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var inherits = require("util").inherits;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function Entry() {
+  assert.ok(this instanceof Entry);
+}
+
+function FunctionEntry(returnLoc) {
+  Entry.call(this);
+  n.Literal.assert(returnLoc);
+  this.returnLoc = returnLoc;
+}
+
+inherits(FunctionEntry, Entry);
+exports.FunctionEntry = FunctionEntry;
+
+function LoopEntry(breakLoc, continueLoc, label) {
+  Entry.call(this);
+
+  n.Literal.assert(breakLoc);
+  n.Literal.assert(continueLoc);
+
+  if (label) {
+    n.Identifier.assert(label);
+  } else {
+    label = null;
+  }
+
+  this.breakLoc = breakLoc;
+  this.continueLoc = continueLoc;
+  this.label = label;
+}
+
+inherits(LoopEntry, Entry);
+exports.LoopEntry = LoopEntry;
+
+function SwitchEntry(breakLoc) {
+  Entry.call(this);
+  n.Literal.assert(breakLoc);
+  this.breakLoc = breakLoc;
+}
+
+inherits(SwitchEntry, Entry);
+exports.SwitchEntry = SwitchEntry;
+
+function TryEntry(firstLoc, catchEntry, finallyEntry) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+
+  if (catchEntry) {
+    assert.ok(catchEntry instanceof CatchEntry);
+  } else {
+    catchEntry = null;
+  }
+
+  if (finallyEntry) {
+    assert.ok(finallyEntry instanceof FinallyEntry);
+  } else {
+    finallyEntry = null;
+  }
+
+  // Have to have one or the other (or both).
+  assert.ok(catchEntry || finallyEntry);
+
+  this.firstLoc = firstLoc;
+  this.catchEntry = catchEntry;
+  this.finallyEntry = finallyEntry;
+}
+
+inherits(TryEntry, Entry);
+exports.TryEntry = TryEntry;
+
+function CatchEntry(firstLoc, paramId) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+  n.Identifier.assert(paramId);
+
+  this.firstLoc = firstLoc;
+  this.paramId = paramId;
+}
+
+inherits(CatchEntry, Entry);
+exports.CatchEntry = CatchEntry;
+
+function FinallyEntry(firstLoc, afterLoc) {
+  Entry.call(this);
+  n.Literal.assert(firstLoc);
+  n.Literal.assert(afterLoc);
+  this.firstLoc = firstLoc;
+  this.afterLoc = afterLoc;
+}
+
+inherits(FinallyEntry, Entry);
+exports.FinallyEntry = FinallyEntry;
+
+function LabeledEntry(breakLoc, label) {
+  Entry.call(this);
+
+  n.Literal.assert(breakLoc);
+  n.Identifier.assert(label);
+
+  this.breakLoc = breakLoc;
+  this.label = label;
+}
+
+inherits(LabeledEntry, Entry);
+exports.LabeledEntry = LabeledEntry;
+
+function LeapManager(emitter) {
+  assert.ok(this instanceof LeapManager);
+
+  var Emitter = require("./emit").Emitter;
+  assert.ok(emitter instanceof Emitter);
+
+  this.emitter = emitter;
+  this.entryStack = [new FunctionEntry(emitter.finalLoc)];
+}
+
+var LMp = LeapManager.prototype;
+exports.LeapManager = LeapManager;
+
+LMp.withEntry = function(entry, callback) {
+  assert.ok(entry instanceof Entry);
+  this.entryStack.push(entry);
+  try {
+    callback.call(this.emitter);
+  } finally {
+    var popped = this.entryStack.pop();
+    assert.strictEqual(popped, entry);
+  }
+};
+
+LMp._findLeapLocation = function(property, label) {
+  for (var i = this.entryStack.length - 1; i >= 0; --i) {
+    var entry = this.entryStack[i];
+    var loc = entry[property];
+    if (loc) {
+      if (label) {
+        if (entry.label &&
+            entry.label.name === label.name) {
+          return loc;
+        }
+      } else if (entry instanceof LabeledEntry) {
+        // Ignore LabeledEntry entries unless we are actually breaking to
+        // a label.
+      } else {
+        return loc;
+      }
+    }
+  }
+
+  return null;
+};
+
+LMp.getBreakLoc = function(label) {
+  return this._findLeapLocation("breakLoc", label);
+};
+
+LMp.getContinueLoc = function(label) {
+  return this._findLeapLocation("continueLoc", label);
+};
+
+},{"./emit":306,"assert":138,"ast-types":136,"util":163}],309:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var m = require("private").makeAccessor();
+var types = require("ast-types");
+var isArray = types.builtInTypes.array;
+var n = types.namedTypes;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function makePredicate(propertyName, knownTypes) {
+  function onlyChildren(node) {
+    n.Node.assert(node);
+
+    // Assume no side effects until we find out otherwise.
+    var result = false;
+
+    function check(child) {
+      if (result) {
+        // Do nothing.
+      } else if (isArray.check(child)) {
+        child.some(check);
+      } else if (n.Node.check(child)) {
+        assert.strictEqual(result, false);
+        result = predicate(child);
+      }
+      return result;
+    }
+
+    types.eachField(node, function(name, child) {
+      check(child);
+    });
+
+    return result;
+  }
+
+  function predicate(node) {
+    n.Node.assert(node);
+
+    var meta = m(node);
+    if (hasOwn.call(meta, propertyName))
+      return meta[propertyName];
+
+    // Certain types are "opaque," which means they have no side
+    // effects or leaps and we don't care about their subexpressions.
+    if (hasOwn.call(opaqueTypes, node.type))
+      return meta[propertyName] = false;
+
+    if (hasOwn.call(knownTypes, node.type))
+      return meta[propertyName] = true;
+
+    return meta[propertyName] = onlyChildren(node);
+  }
+
+  predicate.onlyChildren = onlyChildren;
+
+  return predicate;
+}
+
+var opaqueTypes = {
+  FunctionExpression: true
+};
+
+// These types potentially have side effects regardless of what side
+// effects their subexpressions have.
+var sideEffectTypes = {
+  CallExpression: true, // Anything could happen!
+  ForInStatement: true, // Modifies the key variable.
+  UnaryExpression: true, // Think delete.
+  BinaryExpression: true, // Might invoke .toString() or .valueOf().
+  AssignmentExpression: true, // Side-effecting by definition.
+  UpdateExpression: true, // Updates are essentially assignments.
+  NewExpression: true // Similar to CallExpression.
+};
+
+// These types are the direct cause of all leaps in control flow.
+var leapTypes = {
+  YieldExpression: true,
+  BreakStatement: true,
+  ContinueStatement: true,
+  ReturnStatement: true,
+  ThrowStatement: true
+};
+
+// All leap types are also side effect types.
+for (var type in leapTypes) {
+  if (hasOwn.call(leapTypes, type)) {
+    sideEffectTypes[type] = leapTypes[type];
+  }
+}
+
+exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
+exports.containsLeap = makePredicate("containsLeap", leapTypes);
+
+},{"assert":138,"ast-types":136,"private":305}],310:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+exports.defaults = function(obj) {
+  var len = arguments.length;
+  var extension;
+
+  for (var i = 1; i < len; ++i) {
+    if ((extension = arguments[i])) {
+      for (var key in extension) {
+        if (hasOwn.call(extension, key) && !hasOwn.call(obj, key)) {
+          obj[key] = extension[key];
+        }
+      }
+    }
+  }
+
+  return obj;
+};
+
+exports.runtimeProperty = function(name) {
+  return b.memberExpression(
+    b.identifier("regeneratorRuntime"),
+    b.identifier(name),
+    false
+  );
+};
+
+// Inspired by the isReference function from ast-util:
+// https://github.com/eventualbuddha/ast-util/blob/9bf91c5ce8/lib/index.js#L466-L506
+exports.isReference = function(path, name) {
+  var node = path.value;
+
+  if (!n.Identifier.check(node)) {
+    return false;
+  }
+
+  if (name && node.name !== name) {
+    return false;
+  }
+
+  var parent = path.parent.value;
+
+  switch (parent.type) {
+  case "VariableDeclarator":
+    return path.name === "init";
+
+  case "MemberExpression":
+    return path.name === "object" || (
+      parent.computed && path.name === "property"
+    );
+
+  case "FunctionExpression":
+  case "FunctionDeclaration":
+  case "ArrowFunctionExpression":
+    if (path.name === "id") {
+      return false;
+    }
+
+    if (parent.params === path.parentPath &&
+        parent.params[path.name] === node) {
+      return false;
+    }
+
+    return true;
+
+  case "ClassDeclaration":
+  case "ClassExpression":
+    return path.name !== "id";
+
+  case "CatchClause":
+    return path.name !== "param";
+
+  case "Property":
+  case "MethodDefinition":
+    return path.name !== "key";
+
+  case "ImportSpecifier":
+  case "ImportDefaultSpecifier":
+  case "ImportNamespaceSpecifier":
+  case "LabeledStatement":
+    return false;
+
+  default:
+    return true;
+  }
+};
+
+},{"assert":138,"ast-types":136}],311:[function(require,module,exports){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var fs = require("fs");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var isArray = types.builtInTypes.array;
+var isObject = types.builtInTypes.object;
+var NodePath = types.NodePath;
+var hoist = require("./hoist").hoist;
+var Emitter = require("./emit").Emitter;
+var runtimeProperty = require("./util").runtimeProperty;
+
+exports.transform = function transform(node, options) {
+  options = options || {};
+
+  var path = node instanceof NodePath ? node : new NodePath(node);
+  visitor.visit(path, options);
+  node = path.value;
+
+  options.madeChanges = visitor.wasChangeReported();
+
+  return node;
+};
+
+var visitor = types.PathVisitor.fromMethodsObject({
+  reset: function(node, options) {
+    this.options = options;
+  },
+
+  visitFunction: function(path) {
+    // Calling this.traverse(path) first makes for a post-order traversal.
+    this.traverse(path);
+
+    var node = path.value;
+    var shouldTransformAsync = node.async && !this.options.disableAsync;
+
+    if (!node.generator && !shouldTransformAsync) {
+      return;
+    }
+
+    this.reportChanged();
+
+    node.generator = false;
+
+    if (node.expression) {
+      // Transform expression lambdas into normal functions.
+      node.expression = false;
+      node.body = b.blockStatement([
+        b.returnStatement(node.body)
+      ]);
+    }
+
+    if (shouldTransformAsync) {
+      awaitVisitor.visit(path.get("body"));
+    }
+
+    var outerFnId = node.id || (
+      node.id = path.scope.parent.declareTemporary("callee$")
+    );
+
+    var outerBody = [];
+    var bodyBlock = path.value.body;
+    bodyBlock.body = bodyBlock.body.filter(function (node) {
+      if (node && node._blockHoist != null) {
+        outerBody.push(node);
+        return false;
+      } else {
+        return true;
+      }
+    });
+
+    var innerFnId = b.identifier(node.id.name + "$");
+    var contextId = path.scope.declareTemporary("context$");
+    var vars = hoist(path);
+
+    var emitter = new Emitter(contextId);
+    emitter.explode(path.get("body"));
+
+    if (vars && vars.declarations.length > 0) {
+      outerBody.push(vars);
+    }
+
+    var wrapArgs = [
+      emitter.getContextFunction(innerFnId),
+      // Async functions don't care about the outer function because they
+      // don't need it to be marked and don't inherit from its .prototype.
+      shouldTransformAsync ? b.literal(null) : outerFnId,
+      b.thisExpression()
+    ];
+
+    var tryLocsList = emitter.getTryLocsList();
+    if (tryLocsList) {
+      wrapArgs.push(tryLocsList);
+    }
+
+    var wrapCall = b.callExpression(
+      shouldTransformAsync ? runtimeProperty("async") : runtimeProperty("wrap"),
+      wrapArgs
+    );
+
+    outerBody.push(b.returnStatement(wrapCall));
+    node.body = b.blockStatement(outerBody);
+    node.body._declarations = bodyBlock._declarations;
+
+    if (shouldTransformAsync) {
+      node.async = false;
+      return;
+    }
+
+    if (n.FunctionDeclaration.check(node)) {
+      var pp = path.parent;
+
+      while (pp && !(n.BlockStatement.check(pp.value) ||
+                     n.Program.check(pp.value))) {
+        pp = pp.parent;
+      }
+
+      if (!pp) {
+        return;
+      }
+
+      // Here we turn the FunctionDeclaration into a named
+      // FunctionExpression that will be assigned to a variable of the
+      // same name at the top of the enclosing block. This is important
+      // for a very subtle reason: named function expressions can refer to
+      // themselves by name without fear that the binding may change due
+      // to code executing outside the function, whereas function
+      // declarations are vulnerable to the following rebinding:
+      //
+      //   function f() { return f }
+      //   var g = f;
+      //   f = "asdf";
+      //   g(); // "asdf"
+      //
+      // One way to prevent the problem illustrated above is to transform
+      // the function declaration thus:
+      //
+      //   var f = function f() { return f };
+      //   var g = f;
+      //   f = "asdf";
+      //   g(); // f
+      //   g()()()()(); // f
+      //
+      // In the code below, we transform generator function declarations
+      // in the following way:
+      //
+      //   gen().next(); // { value: gen, done: true }
+      //   function *gen() {
+      //     return gen;
+      //   }
+      //
+      // becomes something like
+      //
+      //   var gen = runtime.mark(function *gen() {
+      //     return gen;
+      //   });
+      //   gen().next(); // { value: gen, done: true }
+      //
+      // which ensures that the generator body can always reliably refer
+      // to gen by name.
+
+      // Remove the FunctionDeclaration so that we can add it back as a
+      // FunctionExpression passed to runtime.mark.
+      path.replace();
+
+      // Change the type of the function to be an expression instead of a
+      // declaration. Note that all the other fields are the same.
+      node.type = "FunctionExpression";
+
+      var varDecl = b.variableDeclaration("var", [
+        b.variableDeclarator(
+          node.id,
+          b.callExpression(runtimeProperty("mark"), [node])
+        )
+      ]);
+
+      if (node.comments) {
+        // Copy any comments preceding the function declaration to the
+        // variable declaration, to avoid weird formatting consequences.
+        varDecl.leadingComments = node.leadingComments;
+        varDecl.trailingComments = node.trailingComments;
+        node.leadingComments = null;
+        node.trailingComments = null;
+      }
+
+      varDecl._blockHoist = 3;
+
+      var bodyPath = pp.get("body");
+      var bodyLen = bodyPath.value.length;
+
+      bodyPath.push(varDecl);
+
+    } else {
+      n.FunctionExpression.assert(node);
+      return b.callExpression(runtimeProperty("mark"), [node]);
+    }
+  }
+});
+
+function shouldNotHoistAbove(stmtPath) {
+  var value = stmtPath.value;
+  n.Statement.assert(value);
+
+  // If the first statement is a "use strict" declaration, make sure to
+  // insert hoisted declarations afterwards.
+  if (n.ExpressionStatement.check(value) &&
+      n.Literal.check(value.expression) &&
+      value.expression.value === "use strict") {
+    return true;
+  }
+
+  if (n.VariableDeclaration.check(value)) {
+    for (var i = 0; i < value.declarations.length; ++i) {
+      var decl = value.declarations[i];
+      if (n.CallExpression.check(decl.init) &&
+          types.astNodesAreEquivalent(decl.init.callee,
+                                      runtimeProperty("mark"))) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+var awaitVisitor = types.PathVisitor.fromMethodsObject({
+  visitFunction: function(path) {
+    return false; // Don't descend into nested function scopes.
+  },
+
+  visitAwaitExpression: function(path) {
+    // Convert await and await* expressions to yield expressions.
+    var argument = path.value.argument;
+
+    // If the parser supports await* syntax using a boolean .all property
+    // (#171), desugar that syntax to yield Promise.all(argument).
+    if (path.value.all) {
+      argument = b.callExpression(
+        b.memberExpression(
+          b.identifier("Promise"),
+          b.identifier("all"),
+          false
+        ),
+        [argument]
+      );
+    }
+
+    return b.yieldExpression(argument, false);
+  }
+});
+
+},{"./emit":306,"./hoist":307,"./util":310,"assert":138,"ast-types":136,"fs":137}],312:[function(require,module,exports){
+(function (__dirname){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var path = require("path");
+var fs = require("fs");
+var through = require("through");
+var transform = require("./lib/visit").transform;
+var utils = require("./lib/util");
+var types = require("ast-types");
+var genOrAsyncFunExp = /\bfunction\s*\*|\basync\b/;
+var blockBindingExp = /\b(let|const)\s+/;
+
+function exports(file, options) {
+  var data = [];
+  return through(write, end);
+
+  function write(buf) {
+    data.push(buf);
+  }
+
+  function end() {
+    this.queue(compile(data.join(""), options).code);
+    this.queue(null);
+  }
+}
+
+// To get a writable stream for use as a browserify transform, call
+// require("regenerator")().
+module.exports = exports;
+
+// To include the runtime globally in the current node process, call
+// require("regenerator").runtime().
+function runtime() {
+  require("./runtime");
+}
+exports.runtime = runtime;
+runtime.path = path.join(__dirname, "runtime.js");
+
+// To modify an AST directly, call require("regenerator").transform(ast).
+exports.transform = transform;
+
+}).call(this,"/node_modules/regenerator-babel")
+},{"./lib/util":310,"./lib/visit":311,"./runtime":314,"assert":138,"ast-types":136,"fs":137,"path":146,"through":313}],313:[function(require,module,exports){
+(function (process){
+var Stream = require('stream')
+
+// through
+//
+// a stream that does nothing but re-emit the input.
+// useful for aggregating a series of changing but not ending streams into one stream)
+
+exports = module.exports = through
+through.through = through
+
+//create a readable writable stream.
+
+function through (write, end, opts) {
+  write = write || function (data) { this.queue(data) }
+  end = end || function () { this.queue(null) }
+
+  var ended = false, destroyed = false, buffer = [], _ended = false
+  var stream = new Stream()
+  stream.readable = stream.writable = true
+  stream.paused = false
+
+//  stream.autoPause   = !(opts && opts.autoPause   === false)
+  stream.autoDestroy = !(opts && opts.autoDestroy === false)
+
+  stream.write = function (data) {
+    write.call(this, data)
+    return !stream.paused
+  }
+
+  function drain() {
+    while(buffer.length && !stream.paused) {
+      var data = buffer.shift()
+      if(null === data)
+        return stream.emit('end')
+      else
+        stream.emit('data', data)
+    }
+  }
+
+  stream.queue = stream.push = function (data) {
+//    console.error(ended)
+    if(_ended) return stream
+    if(data == null) _ended = true
+    buffer.push(data)
+    drain()
+    return stream
+  }
+
+  //this will be registered as the first 'end' listener
+  //must call destroy next tick, to make sure we're after any
+  //stream piped from here.
+  //this is only a problem if end is not emitted synchronously.
+  //a nicer way to do this is to make sure this is the last listener for 'end'
+
+  stream.on('end', function () {
+    stream.readable = false
+    if(!stream.writable && stream.autoDestroy)
+      process.nextTick(function () {
+        stream.destroy()
+      })
+  })
+
+  function _end () {
+    stream.writable = false
+    end.call(stream)
+    if(!stream.readable && stream.autoDestroy)
+      stream.destroy()
+  }
+
+  stream.end = function (data) {
+    if(ended) return
+    ended = true
+    if(arguments.length) stream.write(data)
+    _end() // will emit or queue
+    return stream
+  }
+
+  stream.destroy = function () {
+    if(destroyed) return
+    destroyed = true
+    ended = true
+    buffer.length = 0
+    stream.writable = stream.readable = false
+    stream.emit('close')
+    return stream
+  }
+
+  stream.pause = function () {
+    if(stream.paused) return
+    stream.paused = true
+    return stream
+  }
+
+  stream.resume = function () {
+    if(stream.paused) {
+      stream.paused = false
+      stream.emit('resume')
+    }
+    drain()
+    //may have become paused again,
+    //as drain emits 'data'.
+    if(!stream.paused)
+      stream.emit('drain')
+    return stream
+  }
+  return stream
+}
+
+
+}).call(this,require('_process'))
+},{"_process":147,"stream":159}],314:[function(require,module,exports){
+(function (global){
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+!(function(global) {
+  "use strict";
+
+  var hasOwn = Object.prototype.hasOwnProperty;
+  var undefined; // More compressible than void 0.
+  var iteratorSymbol =
+    typeof Symbol === "function" && Symbol.iterator || "@@iterator";
+
+  var inModule = typeof module === "object";
+  var runtime = global.regeneratorRuntime;
+  if (runtime) {
+    if (inModule) {
+      // If regeneratorRuntime is defined globally and we're in a module,
+      // make the exports object identical to regeneratorRuntime.
+      module.exports = runtime;
+    }
+    // Don't bother evaluating the rest of this file if the runtime was
+    // already defined globally.
+    return;
+  }
+
+  // Define the runtime globally (as expected by generated code) as either
+  // module.exports (if we're in a module) or a new, empty object.
+  runtime = global.regeneratorRuntime = inModule ? module.exports : {};
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    return new Generator(innerFn, outerFn, self || null, tryLocsList || []);
+  }
+  runtime.wrap = wrap;
+
+  // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+  function tryCatch(fn, obj, arg) {
+    try {
+      return { type: "normal", arg: fn.call(obj, arg) };
+    } catch (err) {
+      return { type: "throw", arg: err };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+
+  // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+  var ContinueSentinel = {};
+
+  // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunction.displayName = "GeneratorFunction";
+
+  runtime.isGeneratorFunction = function(genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor
+      ? ctor === GeneratorFunction ||
+        // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (ctor.displayName || ctor.name) === "GeneratorFunction"
+      : false;
+  };
+
+  runtime.mark = function(genFun) {
+    genFun.__proto__ = GeneratorFunctionPrototype;
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  };
+
+  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
+    return new Promise(function(resolve, reject) {
+      var generator = wrap(innerFn, outerFn, self, tryLocsList);
+      var callNext = step.bind(generator.next);
+      var callThrow = step.bind(generator["throw"]);
+
+      function step(arg) {
+        var record = tryCatch(this, null, arg);
+        if (record.type === "throw") {
+          reject(record.arg);
+          return;
+        }
+
+        var info = record.arg;
+        if (info.done) {
+          resolve(info.value);
+        } else {
+          Promise.resolve(info.value).then(callNext, callThrow);
+        }
+      }
+
+      callNext();
+    });
+  };
+
+  function Generator(innerFn, outerFn, self, tryLocsList) {
+    var generator = outerFn ? Object.create(outerFn.prototype) : this;
+    var context = new Context(tryLocsList);
+    var state = GenStateSuspendedStart;
+
+    function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+        return doneResult();
+      }
+
+      while (true) {
+        var delegate = context.delegate;
+        if (delegate) {
+          var record = tryCatch(
+            delegate.iterator[method],
+            delegate.iterator,
+            arg
+          );
+
+          if (record.type === "throw") {
+            context.delegate = null;
+
+            // Like returning generator.throw(uncaught), but without the
+            // overhead of an extra function call.
+            method = "throw";
+            arg = record.arg;
+
+            continue;
+          }
+
+          // Delegate generator ran and handled its own exceptions so
+          // regardless of what the method was, we continue as if it is
+          // "next" with an undefined arg.
+          method = "next";
+          arg = undefined;
+
+          var info = record.arg;
+          if (info.done) {
+            context[delegate.resultName] = info.value;
+            context.next = delegate.nextLoc;
+          } else {
+            state = GenStateSuspendedYield;
+            return info;
+          }
+
+          context.delegate = null;
+        }
+
+        if (method === "next") {
+          if (state === GenStateSuspendedStart &&
+              typeof arg !== "undefined") {
+            // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+            throw new TypeError(
+              "attempt to send " + JSON.stringify(arg) + " to newborn generator"
+            );
+          }
+
+          if (state === GenStateSuspendedYield) {
+            context.sent = arg;
+          } else {
+            delete context.sent;
+          }
+
+        } else if (method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw arg;
+          }
+
+          if (context.dispatchException(arg)) {
+            // If the dispatched exception was caught by a catch block,
+            // then let that catch block handle the exception normally.
+            method = "next";
+            arg = undefined;
+          }
+
+        } else if (method === "return") {
+          context.abrupt("return", arg);
+        }
+
+        state = GenStateExecuting;
+
+        var record = tryCatch(innerFn, self, context);
+        if (record.type === "normal") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done
+            ? GenStateCompleted
+            : GenStateSuspendedYield;
+
+          var info = {
+            value: record.arg,
+            done: context.done
+          };
+
+          if (record.arg === ContinueSentinel) {
+            if (context.delegate && method === "next") {
+              // Deliberately forget the last sent value so that we don't
+              // accidentally pass it on to the delegate.
+              arg = undefined;
+            }
+          } else {
+            return info;
+          }
+
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+
+          if (method === "next") {
+            context.dispatchException(record.arg);
+          } else {
+            arg = record.arg;
+          }
+        }
+      }
+    }
+
+    generator.next = invoke.bind(generator, "next");
+    generator["throw"] = invoke.bind(generator, "throw");
+    generator["return"] = invoke.bind(generator, "return");
+
+    return generator;
+  }
+
+  Gp[iteratorSymbol] = function() {
+    return this;
+  };
+
+  Gp.toString = function() {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = { tryLoc: locs[0] };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    this.tryEntries = [{ tryLoc: "root" }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset();
+  }
+
+  runtime.keys = function(object) {
+    var keys = [];
+    for (var key in object) {
+      keys.push(key);
+    }
+    keys.reverse();
+
+    // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1, next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    // Return an iterator with no values.
+    return { next: doneResult };
+  }
+  runtime.values = values;
+
+  function doneResult() {
+    return { value: undefined, done: true };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+
+    reset: function() {
+      this.prev = 0;
+      this.next = 0;
+      this.sent = undefined;
+      this.done = false;
+      this.delegate = null;
+
+      this.tryEntries.forEach(resetTryEntry);
+
+      // Pre-initialize at least 20 temporary variables to enable hidden
+      // class optimizations for simple generators.
+      for (var tempIndex = 0, tempName;
+           hasOwn.call(this, tempName = "t" + tempIndex) || tempIndex < 20;
+           ++tempIndex) {
+        this[tempName] = null;
+      }
+    },
+
+    stop: function() {
+      this.done = true;
+
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+
+    dispatchException: function(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+
+    abrupt: function(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev &&
+            hasOwn.call(entry, "finallyLoc") &&
+            this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry &&
+          (type === "break" ||
+           type === "continue") &&
+          finallyEntry.tryLoc <= arg &&
+          arg < finallyEntry.finallyLoc) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.next = finallyEntry.finallyLoc;
+      } else {
+        this.complete(record);
+      }
+
+      return ContinueSentinel;
+    },
+
+    complete: function(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" ||
+          record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = record.arg;
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+
+      return ContinueSentinel;
+    },
+
+    finish: function(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) {
+          return this.complete(entry.completion, entry.afterLoc);
+        }
+      }
+    },
+
+    "catch": function(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+
+      // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+      throw new Error("illegal catch attempt");
+    },
+
+    delegateYield: function(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      return ContinueSentinel;
+    }
+  };
+})(
+  // Among the various tricks for obtaining a reference to the global
+  // object, this seems to be the most reliable technique that does not
+  // use indirect eval (which violates Content Security Policy).
+  typeof global === "object" ? global :
+  typeof window === "object" ? window : this
+);
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],315:[function(require,module,exports){
+// Generated by `/scripts/character-class-escape-sets.js`. Do not edit.
+var regenerate = require('regenerate');
+
+exports.REGULAR = {
+	'd': regenerate()
+		.addRange(0x30, 0x39),
+	'D': regenerate()
+		.addRange(0x0, 0x2F)
+		.addRange(0x3A, 0xFFFF),
+	's': regenerate(0x20, 0xA0, 0x1680, 0x180E, 0x202F, 0x205F, 0x3000, 0xFEFF)
+		.addRange(0x9, 0xD)
+		.addRange(0x2000, 0x200A)
+		.addRange(0x2028, 0x2029),
+	'S': regenerate()
+		.addRange(0x0, 0x8)
+		.addRange(0xE, 0x1F)
+		.addRange(0x21, 0x9F)
+		.addRange(0xA1, 0x167F)
+		.addRange(0x1681, 0x180D)
+		.addRange(0x180F, 0x1FFF)
+		.addRange(0x200B, 0x2027)
+		.addRange(0x202A, 0x202E)
+		.addRange(0x2030, 0x205E)
+		.addRange(0x2060, 0x2FFF)
+		.addRange(0x3001, 0xFEFE)
+		.addRange(0xFF00, 0xFFFF),
+	'w': regenerate(0x5F)
+		.addRange(0x30, 0x39)
+		.addRange(0x41, 0x5A)
+		.addRange(0x61, 0x7A),
+	'W': regenerate(0x60)
+		.addRange(0x0, 0x2F)
+		.addRange(0x3A, 0x40)
+		.addRange(0x5B, 0x5E)
+		.addRange(0x7B, 0xFFFF)
+};
+
+exports.UNICODE = {
+	'd': regenerate()
+		.addRange(0x30, 0x39),
+	'D': regenerate()
+		.addRange(0x0, 0x2F)
+		.addRange(0x3A, 0x10FFFF),
+	's': regenerate(0x20, 0xA0, 0x1680, 0x180E, 0x202F, 0x205F, 0x3000, 0xFEFF)
+		.addRange(0x9, 0xD)
+		.addRange(0x2000, 0x200A)
+		.addRange(0x2028, 0x2029),
+	'S': regenerate()
+		.addRange(0x0, 0x8)
+		.addRange(0xE, 0x1F)
+		.addRange(0x21, 0x9F)
+		.addRange(0xA1, 0x167F)
+		.addRange(0x1681, 0x180D)
+		.addRange(0x180F, 0x1FFF)
+		.addRange(0x200B, 0x2027)
+		.addRange(0x202A, 0x202E)
+		.addRange(0x2030, 0x205E)
+		.addRange(0x2060, 0x2FFF)
+		.addRange(0x3001, 0xFEFE)
+		.addRange(0xFF00, 0x10FFFF),
+	'w': regenerate(0x5F)
+		.addRange(0x30, 0x39)
+		.addRange(0x41, 0x5A)
+		.addRange(0x61, 0x7A),
+	'W': regenerate(0x60)
+		.addRange(0x0, 0x2F)
+		.addRange(0x3A, 0x40)
+		.addRange(0x5B, 0x5E)
+		.addRange(0x7B, 0x10FFFF)
+};
+
+exports.UNICODE_IGNORE_CASE = {
+	'd': regenerate()
+		.addRange(0x30, 0x39),
+	'D': regenerate()
+		.addRange(0x0, 0x2F)
+		.addRange(0x3A, 0x10FFFF),
+	's': regenerate(0x20, 0xA0, 0x1680, 0x180E, 0x202F, 0x205F, 0x3000, 0xFEFF)
+		.addRange(0x9, 0xD)
+		.addRange(0x2000, 0x200A)
+		.addRange(0x2028, 0x2029),
+	'S': regenerate()
+		.addRange(0x0, 0x8)
+		.addRange(0xE, 0x1F)
+		.addRange(0x21, 0x9F)
+		.addRange(0xA1, 0x167F)
+		.addRange(0x1681, 0x180D)
+		.addRange(0x180F, 0x1FFF)
+		.addRange(0x200B, 0x2027)
+		.addRange(0x202A, 0x202E)
+		.addRange(0x2030, 0x205E)
+		.addRange(0x2060, 0x2FFF)
+		.addRange(0x3001, 0xFEFE)
+		.addRange(0xFF00, 0x10FFFF),
+	'w': regenerate(0x5F, 0x17F, 0x212A)
+		.addRange(0x30, 0x39)
+		.addRange(0x41, 0x5A)
+		.addRange(0x61, 0x7A),
+	'W': regenerate(0x4B, 0x53, 0x60)
+		.addRange(0x0, 0x2F)
+		.addRange(0x3A, 0x40)
+		.addRange(0x5B, 0x5E)
+		.addRange(0x7B, 0x10FFFF)
+};
+
+},{"regenerate":317}],316:[function(require,module,exports){
+module.exports={
+	"75": 8490,
+	"83": 383,
+	"107": 8490,
+	"115": 383,
+	"181": 924,
+	"197": 8491,
+	"383": 83,
+	"452": 453,
+	"453": 452,
+	"455": 456,
+	"456": 455,
+	"458": 459,
+	"459": 458,
+	"497": 498,
+	"498": 497,
+	"837": 8126,
+	"914": 976,
+	"917": 1013,
+	"920": 1012,
+	"921": 8126,
+	"922": 1008,
+	"924": 181,
+	"928": 982,
+	"929": 1009,
+	"931": 962,
+	"934": 981,
+	"937": 8486,
+	"962": 931,
+	"976": 914,
+	"977": 1012,
+	"981": 934,
+	"982": 928,
+	"1008": 922,
+	"1009": 929,
+	"1012": [
+		920,
+		977
+	],
+	"1013": 917,
+	"7776": 7835,
+	"7835": 7776,
+	"8126": [
+		837,
+		921
+	],
+	"8486": 937,
+	"8490": 75,
+	"8491": 197,
+	"66560": 66600,
+	"66561": 66601,
+	"66562": 66602,
+	"66563": 66603,
+	"66564": 66604,
+	"66565": 66605,
+	"66566": 66606,
+	"66567": 66607,
+	"66568": 66608,
+	"66569": 66609,
+	"66570": 66610,
+	"66571": 66611,
+	"66572": 66612,
+	"66573": 66613,
+	"66574": 66614,
+	"66575": 66615,
+	"66576": 66616,
+	"66577": 66617,
+	"66578": 66618,
+	"66579": 66619,
+	"66580": 66620,
+	"66581": 66621,
+	"66582": 66622,
+	"66583": 66623,
+	"66584": 66624,
+	"66585": 66625,
+	"66586": 66626,
+	"66587": 66627,
+	"66588": 66628,
+	"66589": 66629,
+	"66590": 66630,
+	"66591": 66631,
+	"66592": 66632,
+	"66593": 66633,
+	"66594": 66634,
+	"66595": 66635,
+	"66596": 66636,
+	"66597": 66637,
+	"66598": 66638,
+	"66599": 66639,
+	"66600": 66560,
+	"66601": 66561,
+	"66602": 66562,
+	"66603": 66563,
+	"66604": 66564,
+	"66605": 66565,
+	"66606": 66566,
+	"66607": 66567,
+	"66608": 66568,
+	"66609": 66569,
+	"66610": 66570,
+	"66611": 66571,
+	"66612": 66572,
+	"66613": 66573,
+	"66614": 66574,
+	"66615": 66575,
+	"66616": 66576,
+	"66617": 66577,
+	"66618": 66578,
+	"66619": 66579,
+	"66620": 66580,
+	"66621": 66581,
+	"66622": 66582,
+	"66623": 66583,
+	"66624": 66584,
+	"66625": 66585,
+	"66626": 66586,
+	"66627": 66587,
+	"66628": 66588,
+	"66629": 66589,
+	"66630": 66590,
+	"66631": 66591,
+	"66632": 66592,
+	"66633": 66593,
+	"66634": 66594,
+	"66635": 66595,
+	"66636": 66596,
+	"66637": 66597,
+	"66638": 66598,
+	"66639": 66599,
+	"71840": 71872,
+	"71841": 71873,
+	"71842": 71874,
+	"71843": 71875,
+	"71844": 71876,
+	"71845": 71877,
+	"71846": 71878,
+	"71847": 71879,
+	"71848": 71880,
+	"71849": 71881,
+	"71850": 71882,
+	"71851": 71883,
+	"71852": 71884,
+	"71853": 71885,
+	"71854": 71886,
+	"71855": 71887,
+	"71856": 71888,
+	"71857": 71889,
+	"71858": 71890,
+	"71859": 71891,
+	"71860": 71892,
+	"71861": 71893,
+	"71862": 71894,
+	"71863": 71895,
+	"71864": 71896,
+	"71865": 71897,
+	"71866": 71898,
+	"71867": 71899,
+	"71868": 71900,
+	"71869": 71901,
+	"71870": 71902,
+	"71871": 71903,
+	"71872": 71840,
+	"71873": 71841,
+	"71874": 71842,
+	"71875": 71843,
+	"71876": 71844,
+	"71877": 71845,
+	"71878": 71846,
+	"71879": 71847,
+	"71880": 71848,
+	"71881": 71849,
+	"71882": 71850,
+	"71883": 71851,
+	"71884": 71852,
+	"71885": 71853,
+	"71886": 71854,
+	"71887": 71855,
+	"71888": 71856,
+	"71889": 71857,
+	"71890": 71858,
+	"71891": 71859,
+	"71892": 71860,
+	"71893": 71861,
+	"71894": 71862,
+	"71895": 71863,
+	"71896": 71864,
+	"71897": 71865,
+	"71898": 71866,
+	"71899": 71867,
+	"71900": 71868,
+	"71901": 71869,
+	"71902": 71870,
+	"71903": 71871
+}
+
+},{}],317:[function(require,module,exports){
+(function (global){
+/*! https://mths.be/regenerate v1.2.0 by @mathias | MIT license */
+;(function(root) {
+
+	// Detect free variables `exports`.
+	var freeExports = typeof exports == 'object' && exports;
+
+	// Detect free variable `module`.
+	var freeModule = typeof module == 'object' && module &&
+		module.exports == freeExports && module;
+
+	// Detect free variable `global`, from Node.js or Browserified code,
+	// and use it as `root`.
+	var freeGlobal = typeof global == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	var ERRORS = {
+		'rangeOrder': 'A range\u2019s `stop` value must be greater than or equal ' +
+			'to the `start` value.',
+		'codePointRange': 'Invalid code point value. Code points range from ' +
+			'U+000000 to U+10FFFF.'
+	};
+
+	// https://mathiasbynens.be/notes/javascript-encoding#surrogate-pairs
+	var HIGH_SURROGATE_MIN = 0xD800;
+	var HIGH_SURROGATE_MAX = 0xDBFF;
+	var LOW_SURROGATE_MIN = 0xDC00;
+	var LOW_SURROGATE_MAX = 0xDFFF;
+
+	// In Regenerate output, `\0` will never be preceded by `\` because we sort
+	// by code point value, so let’s keep this regular expression simple.
+	var regexNull = /\\x00([^0123456789]|$)/g;
+
+	var object = {};
+	var hasOwnProperty = object.hasOwnProperty;
+	var extend = function(destination, source) {
+		var key;
+		for (key in source) {
+			if (hasOwnProperty.call(source, key)) {
+				destination[key] = source[key];
+			}
+		}
+		return destination;
+	};
+
+	var forEach = function(array, callback) {
+		var index = -1;
+		var length = array.length;
+		while (++index < length) {
+			callback(array[index], index);
+		}
+	};
+
+	var toString = object.toString;
+	var isArray = function(value) {
+		return toString.call(value) == '[object Array]';
+	};
+	var isNumber = function(value) {
+		return typeof value == 'number' ||
+			toString.call(value) == '[object Number]';
+	};
+
+	// This assumes that `number` is a positive integer that `toString()`s nicely
+	// (which is the case for all code point values).
+	var zeroes = '0000';
+	var pad = function(number, totalCharacters) {
+		var string = String(number);
+		return string.length < totalCharacters
+			? (zeroes + string).slice(-totalCharacters)
+			: string;
+	};
+
+	var hex = function(number) {
+		return Number(number).toString(16).toUpperCase();
+	};
+
+	var slice = [].slice;
+
+	/*--------------------------------------------------------------------------*/
+
+	var dataFromCodePoints = function(codePoints) {
+		var index = -1;
+		var length = codePoints.length;
+		var max = length - 1;
+		var result = [];
+		var isStart = true;
+		var tmp;
+		var previous = 0;
+		while (++index < length) {
+			tmp = codePoints[index];
+			if (isStart) {
+				result.push(tmp);
+				previous = tmp;
+				isStart = false;
+			} else {
+				if (tmp == previous + 1) {
+					if (index != max) {
+						previous = tmp;
+						continue;
+					} else {
+						isStart = true;
+						result.push(tmp + 1);
+					}
+				} else {
+					// End the previous range and start a new one.
+					result.push(previous + 1, tmp);
+					previous = tmp;
+				}
+			}
+		}
+		if (!isStart) {
+			result.push(tmp + 1);
+		}
+		return result;
+	};
+
+	var dataRemove = function(data, codePoint) {
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var length = data.length;
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1];
+			if (codePoint >= start && codePoint < end) {
+				// Modify this pair.
+				if (codePoint == start) {
+					if (end == start + 1) {
+						// Just remove `start` and `end`.
+						data.splice(index, 2);
+						return data;
+					} else {
+						// Just replace `start` with a new value.
+						data[index] = codePoint + 1;
+						return data;
+					}
+				} else if (codePoint == end - 1) {
+					// Just replace `end` with a new value.
+					data[index + 1] = codePoint;
+					return data;
+				} else {
+					// Replace `[start, end]` with `[startA, endA, startB, endB]`.
+					data.splice(index, 2, start, codePoint, codePoint + 1, end);
+					return data;
+				}
+			}
+			index += 2;
+		}
+		return data;
+	};
+
+	var dataRemoveRange = function(data, rangeStart, rangeEnd) {
+		if (rangeEnd < rangeStart) {
+			throw Error(ERRORS.rangeOrder);
+		}
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		while (index < data.length) {
+			start = data[index];
+			end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.
+
+			// Exit as soon as no more matching pairs can be found.
+			if (start > rangeEnd) {
+				return data;
+			}
+
+			// Check if this range pair is equal to, or forms a subset of, the range
+			// to be removed.
+			// E.g. we have `[0, 11, 40, 51]` and want to remove 0-10 → `[40, 51]`.
+			// E.g. we have `[40, 51]` and want to remove 0-100 → `[]`.
+			if (rangeStart <= start && rangeEnd >= end) {
+				// Remove this pair.
+				data.splice(index, 2);
+				continue;
+			}
+
+			// Check if both `rangeStart` and `rangeEnd` are within the bounds of
+			// this pair.
+			// E.g. we have `[0, 11]` and want to remove 4-6 → `[0, 4, 7, 11]`.
+			if (rangeStart >= start && rangeEnd < end) {
+				if (rangeStart == start) {
+					// Replace `[start, end]` with `[startB, endB]`.
+					data[index] = rangeEnd + 1;
+					data[index + 1] = end + 1;
+					return data;
+				}
+				// Replace `[start, end]` with `[startA, endA, startB, endB]`.
+				data.splice(index, 2, start, rangeStart, rangeEnd + 1, end + 1);
+				return data;
+			}
+
+			// Check if only `rangeStart` is within the bounds of this pair.
+			// E.g. we have `[0, 11]` and want to remove 4-20 → `[0, 4]`.
+			if (rangeStart >= start && rangeStart <= end) {
+				// Replace `end` with `rangeStart`.
+				data[index + 1] = rangeStart;
+				// Note: we cannot `return` just yet, in case any following pairs still
+				// contain matching code points.
+				// E.g. we have `[0, 11, 14, 31]` and want to remove 4-20
+				// → `[0, 4, 21, 31]`.
+			}
+
+			// Check if only `rangeEnd` is within the bounds of this pair.
+			// E.g. we have `[14, 31]` and want to remove 4-20 → `[21, 31]`.
+			else if (rangeEnd >= start && rangeEnd <= end) {
+				// Just replace `start`.
+				data[index] = rangeEnd + 1;
+				return data;
+			}
+
+			index += 2;
+		}
+		return data;
+	};
+
+	 var dataAdd = function(data, codePoint) {
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var lastIndex = null;
+		var length = data.length;
+		if (codePoint < 0x0 || codePoint > 0x10FFFF) {
+			throw RangeError(ERRORS.codePointRange);
+		}
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1];
+
+			// Check if the code point is already in the set.
+			if (codePoint >= start && codePoint < end) {
+				return data;
+			}
+
+			if (codePoint == start - 1) {
+				// Just replace `start` with a new value.
+				data[index] = codePoint;
+				return data;
+			}
+
+			// At this point, if `start` is `greater` than `codePoint`, insert a new
+			// `[start, end]` pair before the current pair, or after the current pair
+			// if there is a known `lastIndex`.
+			if (start > codePoint) {
+				data.splice(
+					lastIndex != null ? lastIndex + 2 : 0,
+					0,
+					codePoint,
+					codePoint + 1
+				);
+				return data;
+			}
+
+			if (codePoint == end) {
+				// Check if adding this code point causes two separate ranges to become
+				// a single range, e.g. `dataAdd([0, 4, 5, 10], 4)` → `[0, 10]`.
+				if (codePoint + 1 == data[index + 2]) {
+					data.splice(index, 4, start, data[index + 3]);
+					return data;
+				}
+				// Else, just replace `end` with a new value.
+				data[index + 1] = codePoint + 1;
+				return data;
+			}
+			lastIndex = index;
+			index += 2;
+		}
+		// The loop has finished; add the new pair to the end of the data set.
+		data.push(codePoint, codePoint + 1);
+		return data;
+	};
+
+	var dataAddData = function(dataA, dataB) {
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var data = dataA.slice();
+		var length = dataB.length;
+		while (index < length) {
+			start = dataB[index];
+			end = dataB[index + 1] - 1;
+			if (start == end) {
+				data = dataAdd(data, start);
+			} else {
+				data = dataAddRange(data, start, end);
+			}
+			index += 2;
+		}
+		return data;
+	};
+
+	var dataRemoveData = function(dataA, dataB) {
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var data = dataA.slice();
+		var length = dataB.length;
+		while (index < length) {
+			start = dataB[index];
+			end = dataB[index + 1] - 1;
+			if (start == end) {
+				data = dataRemove(data, start);
+			} else {
+				data = dataRemoveRange(data, start, end);
+			}
+			index += 2;
+		}
+		return data;
+	};
+
+	var dataAddRange = function(data, rangeStart, rangeEnd) {
+		if (rangeEnd < rangeStart) {
+			throw Error(ERRORS.rangeOrder);
+		}
+		if (
+			rangeStart < 0x0 || rangeStart > 0x10FFFF ||
+			rangeEnd < 0x0 || rangeEnd > 0x10FFFF
+		) {
+			throw RangeError(ERRORS.codePointRange);
+		}
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var added = false;
+		var length = data.length;
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1];
+
+			if (added) {
+				// The range has already been added to the set; at this point, we just
+				// need to get rid of the following ranges in case they overlap.
+
+				// Check if this range can be combined with the previous range.
+				if (start == rangeEnd + 1) {
+					data.splice(index - 1, 2);
+					return data;
+				}
+
+				// Exit as soon as no more possibly overlapping pairs can be found.
+				if (start > rangeEnd) {
+					return data;
+				}
+
+				// E.g. `[0, 11, 12, 16]` and we’ve added 5-15, so we now have
+				// `[0, 16, 12, 16]`. Remove the `12,16` part, as it lies within the
+				// `0,16` range that was previously added.
+				if (start >= rangeStart && start <= rangeEnd) {
+					// `start` lies within the range that was previously added.
+
+					if (end > rangeStart && end - 1 <= rangeEnd) {
+						// `end` lies within the range that was previously added as well,
+						// so remove this pair.
+						data.splice(index, 2);
+						index -= 2;
+						// Note: we cannot `return` just yet, as there may still be other
+						// overlapping pairs.
+					} else {
+						// `start` lies within the range that was previously added, but
+						// `end` doesn’t. E.g. `[0, 11, 12, 31]` and we’ve added 5-15, so
+						// now we have `[0, 16, 12, 31]`. This must be written as `[0, 31]`.
+						// Remove the previously added `end` and the current `start`.
+						data.splice(index - 1, 2);
+						index -= 2;
+					}
+
+					// Note: we cannot return yet.
+				}
+
+			}
+
+			else if (start == rangeEnd + 1) {
+				data[index] = rangeStart;
+				return data;
+			}
+
+			// Check if a new pair must be inserted *before* the current one.
+			else if (start > rangeEnd) {
+				data.splice(index, 0, rangeStart, rangeEnd + 1);
+				return data;
+			}
+
+			else if (rangeStart >= start && rangeStart < end && rangeEnd + 1 <= end) {
+				// The new range lies entirely within an existing range pair. No action
+				// needed.
+				return data;
+			}
+
+			else if (
+				// E.g. `[0, 11]` and you add 5-15 → `[0, 16]`.
+				(rangeStart >= start && rangeStart < end) ||
+				// E.g. `[0, 3]` and you add 3-6 → `[0, 7]`.
+				end == rangeStart
+			) {
+				// Replace `end` with the new value.
+				data[index + 1] = rangeEnd + 1;
+				// Make sure the next range pair doesn’t overlap, e.g. `[0, 11, 12, 14]`
+				// and you add 5-15 → `[0, 16]`, i.e. remove the `12,14` part.
+				added = true;
+				// Note: we cannot `return` just yet.
+			}
+
+			else if (rangeStart <= start && rangeEnd + 1 >= end) {
+				// The new range is a superset of the old range.
+				data[index] = rangeStart;
+				data[index + 1] = rangeEnd + 1;
+				added = true;
+			}
+
+			index += 2;
+		}
+		// The loop has finished without doing anything; add the new pair to the end
+		// of the data set.
+		if (!added) {
+			data.push(rangeStart, rangeEnd + 1);
+		}
+		return data;
+	};
+
+	var dataContains = function(data, codePoint) {
+		var index = 0;
+		var length = data.length;
+		// Exit early if `codePoint` is not within `data`’s overall range.
+		var start = data[index];
+		var end = data[length - 1];
+		if (length >= 2) {
+			if (codePoint < start || codePoint > end) {
+				return false;
+			}
+		}
+		// Iterate over the data per `(start, end)` pair.
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1];
+			if (codePoint >= start && codePoint < end) {
+				return true;
+			}
+			index += 2;
+		}
+		return false;
+	};
+
+	var dataIntersection = function(data, codePoints) {
+		var index = 0;
+		var length = codePoints.length;
+		var codePoint;
+		var result = [];
+		while (index < length) {
+			codePoint = codePoints[index];
+			if (dataContains(data, codePoint)) {
+				result.push(codePoint);
+			}
+			++index;
+		}
+		return dataFromCodePoints(result);
+	};
+
+	var dataIsEmpty = function(data) {
+		return !data.length;
+	};
+
+	var dataIsSingleton = function(data) {
+		// Check if the set only represents a single code point.
+		return data.length == 2 && data[0] + 1 == data[1];
+	};
+
+	var dataToArray = function(data) {
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var result = [];
+		var length = data.length;
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1];
+			while (start < end) {
+				result.push(start);
+				++start;
+			}
+			index += 2;
+		}
+		return result;
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+	var floor = Math.floor;
+	var highSurrogate = function(codePoint) {
+		return parseInt(
+			floor((codePoint - 0x10000) / 0x400) + HIGH_SURROGATE_MIN,
+			10
+		);
+	};
+
+	var lowSurrogate = function(codePoint) {
+		return parseInt(
+			(codePoint - 0x10000) % 0x400 + LOW_SURROGATE_MIN,
+			10
+		);
+	};
+
+	var stringFromCharCode = String.fromCharCode;
+	var codePointToString = function(codePoint) {
+		var string;
+		// https://mathiasbynens.be/notes/javascript-escapes#single
+		// Note: the `\b` escape sequence for U+0008 BACKSPACE in strings has a
+		// different meaning in regular expressions (word boundary), so it cannot
+		// be used here.
+		if (codePoint == 0x09) {
+			string = '\\t';
+		}
+		// Note: IE < 9 treats `'\v'` as `'v'`, so avoid using it.
+		// else if (codePoint == 0x0B) {
+		// 	string = '\\v';
+		// }
+		else if (codePoint == 0x0A) {
+			string = '\\n';
+		}
+		else if (codePoint == 0x0C) {
+			string = '\\f';
+		}
+		else if (codePoint == 0x0D) {
+			string = '\\r';
+		}
+		else if (codePoint == 0x5C) {
+			string = '\\\\';
+		}
+		else if (
+			codePoint == 0x24 ||
+			(codePoint >= 0x28 && codePoint <= 0x2B) ||
+			codePoint == 0x2D || codePoint == 0x2E || codePoint == 0x3F ||
+			(codePoint >= 0x5B && codePoint <= 0x5E) ||
+			(codePoint >= 0x7B && codePoint <= 0x7D)
+		) {
+			// The code point maps to an unsafe printable ASCII character;
+			// backslash-escape it. Here’s the list of those symbols:
+			//
+			//     $()*+-.?[\]^{|}
+			//
+			// See #7 for more info.
+			string = '\\' + stringFromCharCode(codePoint);
+		}
+		else if (codePoint >= 0x20 && codePoint <= 0x7E) {
+			// The code point maps to one of these printable ASCII symbols
+			// (including the space character):
+			//
+			//      !"#%&',/0123456789:;<=>@ABCDEFGHIJKLMNO
+			//     PQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz~
+			//
+			// These can safely be used directly.
+			string = stringFromCharCode(codePoint);
+		}
+		else if (codePoint <= 0xFF) {
+			// https://mathiasbynens.be/notes/javascript-escapes#hexadecimal
+			string = '\\x' + pad(hex(codePoint), 2);
+		}
+		else { // `codePoint <= 0xFFFF` holds true.
+			// https://mathiasbynens.be/notes/javascript-escapes#unicode
+			string = '\\u' + pad(hex(codePoint), 4);
+		}
+
+		// There’s no need to account for astral symbols / surrogate pairs here,
+		// since `codePointToString` is private and only used for BMP code points.
+		// But if that’s what you need, just add an `else` block with this code:
+		//
+		//     string = '\\u' + pad(hex(highSurrogate(codePoint)), 4)
+		//     	+ '\\u' + pad(hex(lowSurrogate(codePoint)), 4);
+
+		return string;
+	};
+
+	var symbolToCodePoint = function(symbol) {
+		var length = symbol.length;
+		var first = symbol.charCodeAt(0);
+		var second;
+		if (
+			first >= HIGH_SURROGATE_MIN && first <= HIGH_SURROGATE_MAX &&
+			length > 1 // There is a next code unit.
+		) {
+			// `first` is a high surrogate, and there is a next character. Assume
+			// it’s a low surrogate (else it’s invalid usage of Regenerate anyway).
+			second = symbol.charCodeAt(1);
+			// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+			return (first - HIGH_SURROGATE_MIN) * 0x400 +
+				second - LOW_SURROGATE_MIN + 0x10000;
+		}
+		return first;
+	};
+
+	var createBMPCharacterClasses = function(data) {
+		// Iterate over the data per `(start, end)` pair.
+		var result = '';
+		var index = 0;
+		var start;
+		var end;
+		var length = data.length;
+		if (dataIsSingleton(data)) {
+			return codePointToString(data[0]);
+		}
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.
+			if (start == end) {
+				result += codePointToString(start);
+			} else if (start + 1 == end) {
+				result += codePointToString(start) + codePointToString(end);
+			} else {
+				result += codePointToString(start) + '-' + codePointToString(end);
+			}
+			index += 2;
+		}
+		return '[' + result + ']';
+	};
+
+	var splitAtBMP = function(data) {
+		// Iterate over the data per `(start, end)` pair.
+		var loneHighSurrogates = [];
+		var loneLowSurrogates = [];
+		var bmp = [];
+		var astral = [];
+		var index = 0;
+		var start;
+		var end;
+		var length = data.length;
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1] - 1; // Note: the `- 1` makes `end` inclusive.
+
+			if (start < HIGH_SURROGATE_MIN) {
+
+				// The range starts and ends before the high surrogate range.
+				// E.g. (0, 0x10).
+				if (end < HIGH_SURROGATE_MIN) {
+					bmp.push(start, end + 1);
+				}
+
+				// The range starts before the high surrogate range and ends within it.
+				// E.g. (0, 0xD855).
+				if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {
+					bmp.push(start, HIGH_SURROGATE_MIN);
+					loneHighSurrogates.push(HIGH_SURROGATE_MIN, end + 1);
+				}
+
+				// The range starts before the high surrogate range and ends in the low
+				// surrogate range. E.g. (0, 0xDCFF).
+				if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
+					bmp.push(start, HIGH_SURROGATE_MIN);
+					loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);
+					loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);
+				}
+
+				// The range starts before the high surrogate range and ends after the
+				// low surrogate range. E.g. (0, 0x10FFFF).
+				if (end > LOW_SURROGATE_MAX) {
+					bmp.push(start, HIGH_SURROGATE_MIN);
+					loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);
+					loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);
+					if (end <= 0xFFFF) {
+						bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
+					} else {
+						bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
+						astral.push(0xFFFF + 1, end + 1);
+					}
+				}
+
+			} else if (start >= HIGH_SURROGATE_MIN && start <= HIGH_SURROGATE_MAX) {
+
+				// The range starts and ends in the high surrogate range.
+				// E.g. (0xD855, 0xD866).
+				if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {
+					loneHighSurrogates.push(start, end + 1);
+				}
+
+				// The range starts in the high surrogate range and ends in the low
+				// surrogate range. E.g. (0xD855, 0xDCFF).
+				if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
+					loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);
+					loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);
+				}
+
+				// The range starts in the high surrogate range and ends after the low
+				// surrogate range. E.g. (0xD855, 0x10FFFF).
+				if (end > LOW_SURROGATE_MAX) {
+					loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);
+					loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);
+					if (end <= 0xFFFF) {
+						bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
+					} else {
+						bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
+						astral.push(0xFFFF + 1, end + 1);
+					}
+				}
+
+			} else if (start >= LOW_SURROGATE_MIN && start <= LOW_SURROGATE_MAX) {
+
+				// The range starts and ends in the low surrogate range.
+				// E.g. (0xDCFF, 0xDDFF).
+				if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
+					loneLowSurrogates.push(start, end + 1);
+				}
+
+				// The range starts in the low surrogate range and ends after the low
+				// surrogate range. E.g. (0xDCFF, 0x10FFFF).
+				if (end > LOW_SURROGATE_MAX) {
+					loneLowSurrogates.push(start, LOW_SURROGATE_MAX + 1);
+					if (end <= 0xFFFF) {
+						bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
+					} else {
+						bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
+						astral.push(0xFFFF + 1, end + 1);
+					}
+				}
+
+			} else if (start > LOW_SURROGATE_MAX && start <= 0xFFFF) {
+
+				// The range starts and ends after the low surrogate range.
+				// E.g. (0xFFAA, 0x10FFFF).
+				if (end <= 0xFFFF) {
+					bmp.push(start, end + 1);
+				} else {
+					bmp.push(start, 0xFFFF + 1);
+					astral.push(0xFFFF + 1, end + 1);
+				}
+
+			} else {
+
+				// The range starts and ends in the astral range.
+				astral.push(start, end + 1);
+
+			}
+
+			index += 2;
+		}
+		return {
+			'loneHighSurrogates': loneHighSurrogates,
+			'loneLowSurrogates': loneLowSurrogates,
+			'bmp': bmp,
+			'astral': astral
+		};
+	};
+
+	var optimizeSurrogateMappings = function(surrogateMappings) {
+		var result = [];
+		var tmpLow = [];
+		var addLow = false;
+		var mapping;
+		var nextMapping;
+		var highSurrogates;
+		var lowSurrogates;
+		var nextHighSurrogates;
+		var nextLowSurrogates;
+		var index = -1;
+		var length = surrogateMappings.length;
+		while (++index < length) {
+			mapping = surrogateMappings[index];
+			nextMapping = surrogateMappings[index + 1];
+			if (!nextMapping) {
+				result.push(mapping);
+				continue;
+			}
+			highSurrogates = mapping[0];
+			lowSurrogates = mapping[1];
+			nextHighSurrogates = nextMapping[0];
+			nextLowSurrogates = nextMapping[1];
+
+			// Check for identical high surrogate ranges.
+			tmpLow = lowSurrogates;
+			while (
+				nextHighSurrogates &&
+				highSurrogates[0] == nextHighSurrogates[0] &&
+				highSurrogates[1] == nextHighSurrogates[1]
+			) {
+				// Merge with the next item.
+				if (dataIsSingleton(nextLowSurrogates)) {
+					tmpLow = dataAdd(tmpLow, nextLowSurrogates[0]);
+				} else {
+					tmpLow = dataAddRange(
+						tmpLow,
+						nextLowSurrogates[0],
+						nextLowSurrogates[1] - 1
+					);
+				}
+				++index;
+				mapping = surrogateMappings[index];
+				highSurrogates = mapping[0];
+				lowSurrogates = mapping[1];
+				nextMapping = surrogateMappings[index + 1];
+				nextHighSurrogates = nextMapping && nextMapping[0];
+				nextLowSurrogates = nextMapping && nextMapping[1];
+				addLow = true;
+			}
+			result.push([
+				highSurrogates,
+				addLow ? tmpLow : lowSurrogates
+			]);
+			addLow = false;
+		}
+		return optimizeByLowSurrogates(result);
+	};
+
+	var optimizeByLowSurrogates = function(surrogateMappings) {
+		if (surrogateMappings.length == 1) {
+			return surrogateMappings;
+		}
+		var index = -1;
+		var innerIndex = -1;
+		while (++index < surrogateMappings.length) {
+			var mapping = surrogateMappings[index];
+			var lowSurrogates = mapping[1];
+			var lowSurrogateStart = lowSurrogates[0];
+			var lowSurrogateEnd = lowSurrogates[1];
+			innerIndex = index; // Note: the loop starts at the next index.
+			while (++innerIndex < surrogateMappings.length) {
+				var otherMapping = surrogateMappings[innerIndex];
+				var otherLowSurrogates = otherMapping[1];
+				var otherLowSurrogateStart = otherLowSurrogates[0];
+				var otherLowSurrogateEnd = otherLowSurrogates[1];
+				if (
+					lowSurrogateStart == otherLowSurrogateStart &&
+					lowSurrogateEnd == otherLowSurrogateEnd
+				) {
+					// Add the code points in the other item to this one.
+					if (dataIsSingleton(otherMapping[0])) {
+						mapping[0] = dataAdd(mapping[0], otherMapping[0][0]);
+					} else {
+						mapping[0] = dataAddRange(
+							mapping[0],
+							otherMapping[0][0],
+							otherMapping[0][1] - 1
+						);
+					}
+					// Remove the other, now redundant, item.
+					surrogateMappings.splice(innerIndex, 1);
+					--innerIndex;
+				}
+			}
+		}
+		return surrogateMappings;
+	};
+
+	var surrogateSet = function(data) {
+		// Exit early if `data` is an empty set.
+		if (!data.length) {
+			return [];
+		}
+
+		// Iterate over the data per `(start, end)` pair.
+		var index = 0;
+		var start;
+		var end;
+		var startHigh;
+		var startLow;
+		var prevStartHigh = 0;
+		var prevEndHigh = 0;
+		var tmpLow = [];
+		var endHigh;
+		var endLow;
+		var surrogateMappings = [];
+		var length = data.length;
+		var dataHigh = [];
+		while (index < length) {
+			start = data[index];
+			end = data[index + 1] - 1;
+
+			startHigh = highSurrogate(start);
+			startLow = lowSurrogate(start);
+			endHigh = highSurrogate(end);
+			endLow = lowSurrogate(end);
+
+			var startsWithLowestLowSurrogate = startLow == LOW_SURROGATE_MIN;
+			var endsWithHighestLowSurrogate = endLow == LOW_SURROGATE_MAX;
+			var complete = false;
+
+			// Append the previous high-surrogate-to-low-surrogate mappings.
+			// Step 1: `(startHigh, startLow)` to `(startHigh, LOW_SURROGATE_MAX)`.
+			if (
+				startHigh == endHigh ||
+				startsWithLowestLowSurrogate && endsWithHighestLowSurrogate
+			) {
+				surrogateMappings.push([
+					[startHigh, endHigh + 1],
+					[startLow, endLow + 1]
+				]);
+				complete = true;
+			} else {
+				surrogateMappings.push([
+					[startHigh, startHigh + 1],
+					[startLow, LOW_SURROGATE_MAX + 1]
+				]);
+			}
+
+			// Step 2: `(startHigh + 1, LOW_SURROGATE_MIN)` to
+			// `(endHigh - 1, LOW_SURROGATE_MAX)`.
+			if (!complete && startHigh + 1 < endHigh) {
+				if (endsWithHighestLowSurrogate) {
+					// Combine step 2 and step 3.
+					surrogateMappings.push([
+						[startHigh + 1, endHigh + 1],
+						[LOW_SURROGATE_MIN, endLow + 1]
+					]);
+					complete = true;
+				} else {
+					surrogateMappings.push([
+						[startHigh + 1, endHigh],
+						[LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1]
+					]);
+				}
+			}
+
+			// Step 3. `(endHigh, LOW_SURROGATE_MIN)` to `(endHigh, endLow)`.
+			if (!complete) {
+				surrogateMappings.push([
+					[endHigh, endHigh + 1],
+					[LOW_SURROGATE_MIN, endLow + 1]
+				]);
+			}
+
+			prevStartHigh = startHigh;
+			prevEndHigh = endHigh;
+
+			index += 2;
+		}
+
+		// The format of `surrogateMappings` is as follows:
+		//
+		//     [ surrogateMapping1, surrogateMapping2 ]
+		//
+		// i.e.:
+		//
+		//     [
+		//       [ highSurrogates1, lowSurrogates1 ],
+		//       [ highSurrogates2, lowSurrogates2 ]
+		//     ]
+		return optimizeSurrogateMappings(surrogateMappings);
+	};
+
+	var createSurrogateCharacterClasses = function(surrogateMappings) {
+		var result = [];
+		forEach(surrogateMappings, function(surrogateMapping) {
+			var highSurrogates = surrogateMapping[0];
+			var lowSurrogates = surrogateMapping[1];
+			result.push(
+				createBMPCharacterClasses(highSurrogates) +
+				createBMPCharacterClasses(lowSurrogates)
+			);
+		});
+		return result.join('|');
+	};
+
+	var createCharacterClassesFromData = function(data, bmpOnly) {
+		var result = [];
+
+		var parts = splitAtBMP(data);
+		var loneHighSurrogates = parts.loneHighSurrogates;
+		var loneLowSurrogates = parts.loneLowSurrogates;
+		var bmp = parts.bmp;
+		var astral = parts.astral;
+		var hasAstral = !dataIsEmpty(parts.astral);
+		var hasLoneHighSurrogates = !dataIsEmpty(loneHighSurrogates);
+		var hasLoneLowSurrogates = !dataIsEmpty(loneLowSurrogates);
+
+		var surrogateMappings = surrogateSet(astral);
+
+		if (bmpOnly) {
+			bmp = dataAddData(bmp, loneHighSurrogates);
+			hasLoneHighSurrogates = false;
+			bmp = dataAddData(bmp, loneLowSurrogates);
+			hasLoneLowSurrogates = false;
+		}
+
+		if (!dataIsEmpty(bmp)) {
+			// The data set contains BMP code points that are not high surrogates
+			// needed for astral code points in the set.
+			result.push(createBMPCharacterClasses(bmp));
+		}
+		if (surrogateMappings.length) {
+			// The data set contains astral code points; append character classes
+			// based on their surrogate pairs.
+			result.push(createSurrogateCharacterClasses(surrogateMappings));
+		}
+		// https://gist.github.com/mathiasbynens/bbe7f870208abcfec860
+		if (hasLoneHighSurrogates) {
+			result.push(
+				createBMPCharacterClasses(loneHighSurrogates) +
+				// Make sure the high surrogates aren’t part of a surrogate pair.
+				'(?![\\uDC00-\\uDFFF])'
+			);
+		}
+		if (hasLoneLowSurrogates) {
+			result.push(
+				// Make sure the low surrogates aren’t part of a surrogate pair.
+				'(?:[^\\uD800-\\uDBFF]|^)' +
+				createBMPCharacterClasses(loneLowSurrogates)
+			);
+		}
+		return result.join('|');
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	// `regenerate` can be used as a constructor (and new methods can be added to
+	// its prototype) but also as a regular function, the latter of which is the
+	// documented and most common usage. For that reason, it’s not capitalized.
+	var regenerate = function(value) {
+		if (arguments.length > 1) {
+			value = slice.call(arguments);
+		}
+		if (this instanceof regenerate) {
+			this.data = [];
+			return value ? this.add(value) : this;
+		}
+		return (new regenerate).add(value);
+	};
+
+	regenerate.version = '1.2.0';
+
+	var proto = regenerate.prototype;
+	extend(proto, {
+		'add': function(value) {
+			var $this = this;
+			if (value == null) {
+				return $this;
+			}
+			if (value instanceof regenerate) {
+				// Allow passing other Regenerate instances.
+				$this.data = dataAddData($this.data, value.data);
+				return $this;
+			}
+			if (arguments.length > 1) {
+				value = slice.call(arguments);
+			}
+			if (isArray(value)) {
+				forEach(value, function(item) {
+					$this.add(item);
+				});
+				return $this;
+			}
+			$this.data = dataAdd(
+				$this.data,
+				isNumber(value) ? value : symbolToCodePoint(value)
+			);
+			return $this;
+		},
+		'remove': function(value) {
+			var $this = this;
+			if (value == null) {
+				return $this;
+			}
+			if (value instanceof regenerate) {
+				// Allow passing other Regenerate instances.
+				$this.data = dataRemoveData($this.data, value.data);
+				return $this;
+			}
+			if (arguments.length > 1) {
+				value = slice.call(arguments);
+			}
+			if (isArray(value)) {
+				forEach(value, function(item) {
+					$this.remove(item);
+				});
+				return $this;
+			}
+			$this.data = dataRemove(
+				$this.data,
+				isNumber(value) ? value : symbolToCodePoint(value)
+			);
+			return $this;
+		},
+		'addRange': function(start, end) {
+			var $this = this;
+			$this.data = dataAddRange($this.data,
+				isNumber(start) ? start : symbolToCodePoint(start),
+				isNumber(end) ? end : symbolToCodePoint(end)
+			);
+			return $this;
+		},
+		'removeRange': function(start, end) {
+			var $this = this;
+			var startCodePoint = isNumber(start) ? start : symbolToCodePoint(start);
+			var endCodePoint = isNumber(end) ? end : symbolToCodePoint(end);
+			$this.data = dataRemoveRange(
+				$this.data,
+				startCodePoint,
+				endCodePoint
+			);
+			return $this;
+		},
+		'intersection': function(argument) {
+			var $this = this;
+			// Allow passing other Regenerate instances.
+			// TODO: Optimize this by writing and using `dataIntersectionData()`.
+			var array = argument instanceof regenerate ?
+				dataToArray(argument.data) :
+				argument;
+			$this.data = dataIntersection($this.data, array);
+			return $this;
+		},
+		'contains': function(codePoint) {
+			return dataContains(
+				this.data,
+				isNumber(codePoint) ? codePoint : symbolToCodePoint(codePoint)
+			);
+		},
+		'clone': function() {
+			var set = new regenerate;
+			set.data = this.data.slice(0);
+			return set;
+		},
+		'toString': function(options) {
+			var result = createCharacterClassesFromData(
+				this.data,
+				options ? options.bmpOnly : false
+			);
+			// Use `\0` instead of `\x00` where possible.
+			return result.replace(regexNull, '\\0$1');
+		},
+		'toRegExp': function(flags) {
+			return RegExp(this.toString(), flags || '');
+		},
+		'valueOf': function() { // Note: `valueOf` is aliased as `toArray`.
+			return dataToArray(this.data);
+		}
+	});
+
+	proto.toArray = proto.valueOf;
+
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define(function() {
+			return regenerate;
+		});
+	}	else if (freeExports && !freeExports.nodeType) {
+		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = regenerate;
+		} else { // in Narwhal or RingoJS v0.7.0-
+			freeExports.regenerate = regenerate;
+		}
+	} else { // in Rhino or a web browser
+		root.regenerate = regenerate;
+	}
+
+}(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],318:[function(require,module,exports){
+(function (global){
+/*!
+ * RegJSGen
+ * Copyright 2014 Benjamin Tan <https://d10.github.io/>
+ * Available under MIT license <http://d10.mit-license.org/>
+ */
+;(function() {
+  'use strict';
+
+  /** Used to determine if values are of the language type `Object` */
+  var objectTypes = {
+    'function': true,
+    'object': true
+  };
+
+  /** Used as a reference to the global object */
+  var root = (objectTypes[typeof window] && window) || this;
+
+  /** Backup possible global object */
+  var oldRoot = root;
+
+  /** Detect free variable `exports` */
+  var freeExports = objectTypes[typeof exports] && exports;
+
+  /** Detect free variable `module` */
+  var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
+
+  /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
+  var freeGlobal = freeExports && freeModule && typeof global == 'object' && global;
+  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
+    root = freeGlobal;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /*! Based on https://mths.be/fromcodepoint v0.2.0 by @mathias */
+
+  var stringFromCharCode = String.fromCharCode;
+  var floor = Math.floor;
+  function fromCodePoint() {
+    var MAX_SIZE = 0x4000;
+    var codeUnits = [];
+    var highSurrogate;
+    var lowSurrogate;
+    var index = -1;
+    var length = arguments.length;
+    if (!length) {
+      return '';
+    }
+    var result = '';
+    while (++index < length) {
+      var codePoint = Number(arguments[index]);
+      if (
+        !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+        codePoint < 0 || // not a valid Unicode code point
+        codePoint > 0x10FFFF || // not a valid Unicode code point
+        floor(codePoint) != codePoint // not an integer
+      ) {
+        throw RangeError('Invalid code point: ' + codePoint);
+      }
+      if (codePoint <= 0xFFFF) {
+        // BMP code point
+        codeUnits.push(codePoint);
+      } else {
+        // Astral code point; split in surrogate halves
+        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+        codePoint -= 0x10000;
+        highSurrogate = (codePoint >> 10) + 0xD800;
+        lowSurrogate = (codePoint % 0x400) + 0xDC00;
+        codeUnits.push(highSurrogate, lowSurrogate);
+      }
+      if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+        result += stringFromCharCode.apply(null, codeUnits);
+        codeUnits.length = 0;
+      }
+    }
+    return result;
+  }
+
+  function assertType(type, expected) {
+    if (expected.indexOf('|') == -1) {
+      if (type == expected) {
+        return;
+      }
+
+      throw Error('Invalid node type: ' + type);
+    }
+
+    expected = assertType.hasOwnProperty(expected)
+      ? assertType[expected]
+      : (assertType[expected] = RegExp('^(?:' + expected + ')$'));
+
+    if (expected.test(type)) {
+      return;
+    }
+
+    throw Error('Invalid node type: ' + type);
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  function generate(node) {
+    var type = node.type;
+
+    if (generate.hasOwnProperty(type) && typeof generate[type] == 'function') {
+      return generate[type](node);
+    }
+
+    throw Error('Invalid node type: ' + type);
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  function generateAlternative(node) {
+    assertType(node.type, 'alternative');
+
+    var terms = node.body,
+        length = terms ? terms.length : 0;
+
+    if (length == 1) {
+      return generateTerm(terms[0]);
+    } else {
+      var i = -1,
+          result = '';
+
+      while (++i < length) {
+        result += generateTerm(terms[i]);
+      }
+
+      return result;
+    }
+  }
+
+  function generateAnchor(node) {
+    assertType(node.type, 'anchor');
+
+    switch (node.kind) {
+      case 'start':
+        return '^';
+      case 'end':
+        return '$';
+      case 'boundary':
+        return '\\b';
+      case 'not-boundary':
+        return '\\B';
+      default:
+        throw Error('Invalid assertion');
+    }
+  }
+
+  function generateAtom(node) {
+    assertType(node.type, 'anchor|characterClass|characterClassEscape|dot|group|reference|value');
+
+    return generate(node);
+  }
+
+  function generateCharacterClass(node) {
+    assertType(node.type, 'characterClass');
+
+    var classRanges = node.body,
+        length = classRanges ? classRanges.length : 0;
+
+    var i = -1,
+        result = '[';
+
+    if (node.negative) {
+      result += '^';
+    }
+
+    while (++i < length) {
+      result += generateClassAtom(classRanges[i]);
+    }
+
+    result += ']';
+
+    return result;
+  }
+
+  function generateCharacterClassEscape(node) {
+    assertType(node.type, 'characterClassEscape');
+
+    return '\\' + node.value;
+  }
+
+  function generateCharacterClassRange(node) {
+    assertType(node.type, 'characterClassRange');
+
+    var min = node.min,
+        max = node.max;
+
+    if (min.type == 'characterClassRange' || max.type == 'characterClassRange') {
+      throw Error('Invalid character class range');
+    }
+
+    return generateClassAtom(min) + '-' + generateClassAtom(max);
+  }
+
+  function generateClassAtom(node) {
+    assertType(node.type, 'anchor|characterClassEscape|characterClassRange|dot|value');
+
+    return generate(node);
+  }
+
+  function generateDisjunction(node) {
+    assertType(node.type, 'disjunction');
+
+    var body = node.body,
+        length = body ? body.length : 0;
+
+    if (length == 0) {
+      throw Error('No body');
+    } else if (length == 1) {
+      return generate(body[0]);
+    } else {
+      var i = -1,
+          result = '';
+
+      while (++i < length) {
+        if (i != 0) {
+          result += '|';
+        }
+        result += generate(body[i]);
+      }
+
+      return result;
+    }
+  }
+
+  function generateDot(node) {
+    assertType(node.type, 'dot');
+
+    return '.';
+  }
+
+  function generateGroup(node) {
+    assertType(node.type, 'group');
+
+    var result = '(';
+
+    switch (node.behavior) {
+      case 'normal':
+        break;
+      case 'ignore':
+        result += '?:';
+        break;
+      case 'lookahead':
+        result += '?=';
+        break;
+      case 'negativeLookahead':
+        result += '?!';
+        break;
+      default:
+        throw Error('Invalid behaviour: ' + node.behaviour);
+    }
+
+    var body = node.body,
+        length = body ? body.length : 0;
+
+    if (length == 1) {
+      result += generate(body[0]);
+    } else {
+      var i = -1;
+
+      while (++i < length) {
+        result += generate(body[i]);
+      }
+    }
+
+    result += ')';
+
+    return result;
+  }
+
+  function generateQuantifier(node) {
+    assertType(node.type, 'quantifier');
+
+    var quantifier = '',
+        min = node.min,
+        max = node.max;
+
+    switch (max) {
+      case undefined:
+      case null:
+        switch (min) {
+          case 0:
+            quantifier = '*'
+            break;
+          case 1:
+            quantifier = '+';
+            break;
+          default:
+            quantifier = '{' + min + ',}';
+            break;
+        }
+        break;
+      default:
+        if (min == max) {
+          quantifier = '{' + min + '}';
+        }
+        else if (min == 0 && max == 1) {
+          quantifier = '?';
+        } else {
+          quantifier = '{' + min + ',' + max + '}';
+        }
+        break;
+    }
+
+    if (!node.greedy) {
+      quantifier += '?';
+    }
+
+    return generateAtom(node.body[0]) + quantifier;
+  }
+
+  function generateReference(node) {
+    assertType(node.type, 'reference');
+
+    return '\\' + node.matchIndex;
+  }
+
+  function generateTerm(node) {
+    assertType(node.type, 'anchor|characterClass|characterClassEscape|empty|group|quantifier|reference|value');
+
+    return generate(node);
+  }
+
+  function generateValue(node) {
+    assertType(node.type, 'value');
+
+    var kind = node.kind,
+        codePoint = node.codePoint;
+
+    switch (kind) {
+      case 'controlLetter':
+        return '\\c' + fromCodePoint(codePoint + 64);
+      case 'hexadecimalEscape':
+        return '\\x' + ('00' + codePoint.toString(16).toUpperCase()).slice(-2);
+      case 'identifier':
+        return '\\' + fromCodePoint(codePoint);
+      case 'null':
+        return '\\' + codePoint;
+      case 'octal':
+        return '\\' + codePoint.toString(8);
+      case 'singleEscape':
+        switch (codePoint) {
+          case 0x0008:
+            return '\\b';
+          case 0x009:
+            return '\\t';
+          case 0x00A:
+            return '\\n';
+          case 0x00B:
+            return '\\v';
+          case 0x00C:
+            return '\\f';
+          case 0x00D:
+            return '\\r';
+          default:
+            throw Error('Invalid codepoint: ' + codePoint);
+        }
+      case 'symbol':
+        return fromCodePoint(codePoint);
+      case 'unicodeEscape':
+        return '\\u' + ('0000' + codePoint.toString(16).toUpperCase()).slice(-4);
+      case 'unicodeCodePointEscape':
+        return '\\u{' + codePoint.toString(16).toUpperCase() + '}';
+      default:
+        throw Error('Unsupported node kind: ' + kind);
+    }
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  generate.alternative = generateAlternative;
+  generate.anchor = generateAnchor;
+  generate.characterClass = generateCharacterClass;
+  generate.characterClassEscape = generateCharacterClassEscape;
+  generate.characterClassRange = generateCharacterClassRange;
+  generate.disjunction = generateDisjunction;
+  generate.dot = generateDot;
+  generate.group = generateGroup;
+  generate.quantifier = generateQuantifier;
+  generate.reference = generateReference;
+  generate.value = generateValue;
+
+  /*--------------------------------------------------------------------------*/
+
+  // export regjsgen
+  // some AMD build optimizers, like r.js, check for condition patterns like the following:
+  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+    // define as an anonymous module so, through path mapping, it can be aliased
+    define(function() {
+      return {
+        'generate': generate
+      };
+    });
+  }
+  // check for `exports` after `define` in case a build optimizer adds an `exports` object
+  else if (freeExports && freeModule) {
+    // in Narwhal, Node.js, Rhino -require, or RingoJS
+    freeExports.generate = generate;
+  }
+  // in a browser or Rhino
+  else {
+    root.regjsgen = {
+      'generate': generate
+    };
+  }
+}.call(this));
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],319:[function(require,module,exports){
+// regjsparser
+//
+// ==================================================================
+//
+// See ECMA-262 Standard: 15.10.1
+//
+// NOTE: The ECMA-262 standard uses the term "Assertion" for /^/. Here the
+//   term "Anchor" is used.
+//
+// Pattern ::
+//      Disjunction
+//
+// Disjunction ::
+//      Alternative
+//      Alternative | Disjunction
+//
+// Alternative ::
+//      [empty]
+//      Alternative Term
+//
+// Term ::
+//      Anchor
+//      Atom
+//      Atom Quantifier
+//
+// Anchor ::
+//      ^
+//      $
+//      \ b
+//      \ B
+//      ( ? = Disjunction )
+//      ( ? ! Disjunction )
+//
+// Quantifier ::
+//      QuantifierPrefix
+//      QuantifierPrefix ?
+//
+// QuantifierPrefix ::
+//      *
+//      +
+//      ?
+//      { DecimalDigits }
+//      { DecimalDigits , }
+//      { DecimalDigits , DecimalDigits }
+//
+// Atom ::
+//      PatternCharacter
+//      .
+//      \ AtomEscape
+//      CharacterClass
+//      ( Disjunction )
+//      ( ? : Disjunction )
+//
+// PatternCharacter ::
+//      SourceCharacter but not any of: ^ $ \ . * + ? ( ) [ ] { } |
+//
+// AtomEscape ::
+//      DecimalEscape
+//      CharacterEscape
+//      CharacterClassEscape
+//
+// CharacterEscape[U] ::
+//      ControlEscape
+//      c ControlLetter
+//      HexEscapeSequence
+//      RegExpUnicodeEscapeSequence[?U] (ES6)
+//      IdentityEscape[?U]
+//
+// ControlEscape ::
+//      one of f n r t v
+// ControlLetter ::
+//      one of
+//          a b c d e f g h i j k l m n o p q r s t u v w x y z
+//          A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+//
+// IdentityEscape ::
+//      SourceCharacter but not IdentifierPart
+//      <ZWJ>
+//      <ZWNJ>
+//
+// DecimalEscape ::
+//      DecimalIntegerLiteral [lookahead ∉ DecimalDigit]
+//
+// CharacterClassEscape ::
+//      one of d D s S w W
+//
+// CharacterClass ::
+//      [ [lookahead ∉ {^}] ClassRanges ]
+//      [ ^ ClassRanges ]
+//
+// ClassRanges ::
+//      [empty]
+//      NonemptyClassRanges
+//
+// NonemptyClassRanges ::
+//      ClassAtom
+//      ClassAtom NonemptyClassRangesNoDash
+//      ClassAtom - ClassAtom ClassRanges
+//
+// NonemptyClassRangesNoDash ::
+//      ClassAtom
+//      ClassAtomNoDash NonemptyClassRangesNoDash
+//      ClassAtomNoDash - ClassAtom ClassRanges
+//
+// ClassAtom ::
+//      -
+//      ClassAtomNoDash
+//
+// ClassAtomNoDash ::
+//      SourceCharacter but not one of \ or ] or -
+//      \ ClassEscape
+//
+// ClassEscape ::
+//      DecimalEscape
+//      b
+//      CharacterEscape
+//      CharacterClassEscape
+
+(function() {
+
+  function parse(str, flags) {
+    var hasUnicodeFlag = (flags || "").indexOf("u") !== -1;
+    var pos = 0;
+    var closedCaptureCounter = 0;
+
+    function addRaw(node) {
+      node.raw = str.substring(node.range[0], node.range[1]);
+      return node;
+    }
+
+    function updateRawStart(node, start) {
+      node.range[0] = start;
+      return addRaw(node);
+    }
+
+    function createAnchor(kind, rawLength) {
+      return addRaw({
+        type: 'anchor',
+        kind: kind,
+        range: [
+          pos - rawLength,
+          pos
+        ]
+      });
+    }
+
+    function createValue(kind, codePoint, from, to) {
+      return addRaw({
+        type: 'value',
+        kind: kind,
+        codePoint: codePoint,
+        range: [from, to]
+      });
+    }
+
+    function createEscaped(kind, codePoint, value, fromOffset) {
+      fromOffset = fromOffset || 0;
+      return createValue(kind, codePoint, pos - (value.length + fromOffset), pos);
+    }
+
+    function createCharacter(matches) {
+      var _char = matches[0];
+      var first = _char.charCodeAt(0);
+      if (hasUnicodeFlag) {
+        var second;
+        if (_char.length === 1 && first >= 0xD800 && first <= 0xDBFF) {
+          second = lookahead().charCodeAt(0);
+          if (second >= 0xDC00 && second <= 0xDFFF) {
+            // Unicode surrogate pair
+            pos++;
+            return createValue(
+                'symbol',
+                (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000,
+                pos - 2, pos);
+          }
+        }
+      }
+      return createValue('symbol', first, pos - 1, pos);
+    }
+
+    function createDisjunction(alternatives, from, to) {
+      return addRaw({
+        type: 'disjunction',
+        body: alternatives,
+        range: [
+          from,
+          to
+        ]
+      });
+    }
+
+    function createDot() {
+      return addRaw({
+        type: 'dot',
+        range: [
+          pos - 1,
+          pos
+        ]
+      });
+    }
+
+    function createCharacterClassEscape(value) {
+      return addRaw({
+        type: 'characterClassEscape',
+        value: value,
+        range: [
+          pos - 2,
+          pos
+        ]
+      });
+    }
+
+    function createReference(matchIndex) {
+      return addRaw({
+        type: 'reference',
+        matchIndex: parseInt(matchIndex, 10),
+        range: [
+          pos - 1 - matchIndex.length,
+          pos
+        ]
+      });
+    }
+
+    function createGroup(behavior, disjunction, from, to) {
+      return addRaw({
+        type: 'group',
+        behavior: behavior,
+        body: disjunction,
+        range: [
+          from,
+          to
+        ]
+      });
+    }
+
+    function createQuantifier(min, max, from, to) {
+      if (to == null) {
+        from = pos - 1;
+        to = pos;
+      }
+
+      return addRaw({
+        type: 'quantifier',
+        min: min,
+        max: max,
+        greedy: true,
+        body: null, // set later on,
+        range: [
+          from,
+          to
+        ]
+      });
+    }
+
+    function createAlternative(terms, from, to) {
+      return addRaw({
+        type: 'alternative',
+        body: terms,
+        range: [
+          from,
+          to
+        ]
+      });
+    }
+
+    function createCharacterClass(classRanges, negative, from, to) {
+      return addRaw({
+        type: 'characterClass',
+        body: classRanges,
+        negative: negative,
+        range: [
+          from,
+          to
+        ]
+      });
+    }
+
+    function createClassRange(min, max, from, to) {
+      // See 15.10.2.15:
+      if (min.codePoint > max.codePoint) {
+        throw SyntaxError('invalid range in character class');
+      }
+
+      return addRaw({
+        type: 'characterClassRange',
+        min: min,
+        max: max,
+        range: [
+          from,
+          to
+        ]
+      });
+    }
+
+    function flattenBody(body) {
+      if (body.type === 'alternative') {
+        return body.body;
+      } else {
+        return [body];
+      }
+    }
+
+    function isEmpty(obj) {
+      return obj.type === 'empty';
+    }
+
+    function incr(amount) {
+      amount = (amount || 1);
+      var res = str.substring(pos, pos + amount);
+      pos += (amount || 1);
+      return res;
+    }
+
+    function skip(value) {
+      if (!match(value)) {
+        throw SyntaxError('character: ' + value);
+      }
+    }
+
+    function match(value) {
+      if (str.indexOf(value, pos) === pos) {
+        return incr(value.length);
+      }
+    }
+
+    function lookahead() {
+      return str[pos];
+    }
+
+    function current(value) {
+      return str.indexOf(value, pos) === pos;
+    }
+
+    function next(value) {
+      return str[pos + 1] === value;
+    }
+
+    function matchReg(regExp) {
+      var subStr = str.substring(pos);
+      var res = subStr.match(regExp);
+      if (res) {
+        res.range = [];
+        res.range[0] = pos;
+        incr(res[0].length);
+        res.range[1] = pos;
+      }
+      return res;
+    }
+
+    function parseDisjunction() {
+      // Disjunction ::
+      //      Alternative
+      //      Alternative | Disjunction
+      var res = [], from = pos;
+      res.push(parseAlternative());
+
+      while (match('|')) {
+        res.push(parseAlternative());
+      }
+
+      if (res.length === 1) {
+        return res[0];
+      }
+
+      return createDisjunction(res, from, pos);
+    }
+
+    function parseAlternative() {
+      var res = [], from = pos;
+      var term;
+
+      // Alternative ::
+      //      [empty]
+      //      Alternative Term
+      while (term = parseTerm()) {
+        res.push(term);
+      }
+
+      if (res.length === 1) {
+        return res[0];
+      }
+
+      return createAlternative(res, from, pos);
+    }
+
+    function parseTerm() {
+      // Term ::
+      //      Anchor
+      //      Atom
+      //      Atom Quantifier
+
+      if (pos >= str.length || current('|') || current(')')) {
+        return null; /* Means: The term is empty */
+      }
+
+      var anchor = parseAnchor();
+
+      if (anchor) {
+        return anchor;
+      }
+
+      var atom = parseAtom();
+      if (!atom) {
+        throw SyntaxError('Expected atom')
+      }
+      var quantifier = parseQuantifier() || false;
+      if (quantifier) {
+        quantifier.body = flattenBody(atom);
+        // The quantifier contains the atom. Therefore, the beginning of the
+        // quantifier range is given by the beginning of the atom.
+        updateRawStart(quantifier, atom.range[0]);
+        return quantifier;
+      }
+      return atom;
+    }
+
+    function parseGroup(matchA, typeA, matchB, typeB) {
+      var type = null, from = pos;
+
+      if (match(matchA)) {
+        type = typeA;
+      } else if (match(matchB)) {
+        type = typeB;
+      } else {
+        return false;
+      }
+
+      var body = parseDisjunction();
+      if (!body) {
+        throw SyntaxError('Expected disjunction');
+      }
+      skip(')');
+      var group = createGroup(type, flattenBody(body), from, pos);
+
+      if (type == 'normal') {
+        // Keep track of the number of closed groups. This is required for
+        // parseDecimalEscape().
+        closedCaptureCounter++;
+      }
+      return group;
+    }
+
+    function parseAnchor() {
+      // Anchor ::
+      //      ^
+      //      $
+      //      \ b
+      //      \ B
+      //      ( ? = Disjunction )
+      //      ( ? ! Disjunction )
+      var res, from = pos;
+
+      if (match('^')) {
+        return createAnchor('start', 1 /* rawLength */);
+      } else if (match('$')) {
+        return createAnchor('end', 1 /* rawLength */);
+      } else if (match('\\b')) {
+        return createAnchor('boundary', 2 /* rawLength */);
+      } else if (match('\\B')) {
+        return createAnchor('not-boundary', 2 /* rawLength */);
+      } else {
+        return parseGroup('(?=', 'lookahead', '(?!', 'negativeLookahead');
+      }
+    }
+
+    function parseQuantifier() {
+      // Quantifier ::
+      //      QuantifierPrefix
+      //      QuantifierPrefix ?
+      //
+      // QuantifierPrefix ::
+      //      *
+      //      +
+      //      ?
+      //      { DecimalDigits }
+      //      { DecimalDigits , }
+      //      { DecimalDigits , DecimalDigits }
+
+      var res;
+      var quantifier;
+      var min, max;
+
+      if (match('*')) {
+        quantifier = createQuantifier(0);
+      }
+      else if (match('+')) {
+        quantifier = createQuantifier(1);
+      }
+      else if (match('?')) {
+        quantifier = createQuantifier(0, 1);
+      }
+      else if (res = matchReg(/^\{([0-9]+)\}/)) {
+        min = parseInt(res[1], 10);
+        quantifier = createQuantifier(min, min, res.range[0], res.range[1]);
+      }
+      else if (res = matchReg(/^\{([0-9]+),\}/)) {
+        min = parseInt(res[1], 10);
+        quantifier = createQuantifier(min, undefined, res.range[0], res.range[1]);
+      }
+      else if (res = matchReg(/^\{([0-9]+),([0-9]+)\}/)) {
+        min = parseInt(res[1], 10);
+        max = parseInt(res[2], 10);
+        if (min > max) {
+          throw SyntaxError('numbers out of order in {} quantifier');
+        }
+        quantifier = createQuantifier(min, max, res.range[0], res.range[1]);
+      }
+
+      if (quantifier) {
+        if (match('?')) {
+          quantifier.greedy = false;
+          quantifier.range[1] += 1;
+        }
+      }
+
+      return quantifier;
+    }
+
+    function parseAtom() {
+      // Atom ::
+      //      PatternCharacter
+      //      .
+      //      \ AtomEscape
+      //      CharacterClass
+      //      ( Disjunction )
+      //      ( ? : Disjunction )
+
+      var res;
+
+      // jviereck: allow ']', '}' here as well to be compatible with browser's
+      //   implementations: ']'.match(/]/);
+      // if (res = matchReg(/^[^^$\\.*+?()[\]{}|]/)) {
+      if (res = matchReg(/^[^^$\\.*+?(){[|]/)) {
+        //      PatternCharacter
+        return createCharacter(res);
+      }
+      else if (match('.')) {
+        //      .
+        return createDot();
+      }
+      else if (match('\\')) {
+        //      \ AtomEscape
+        res = parseAtomEscape();
+        if (!res) {
+          throw SyntaxError('atomEscape');
+        }
+        return res;
+      }
+      else if (res = parseCharacterClass()) {
+        return res;
+      }
+      else {
+        //      ( Disjunction )
+        //      ( ? : Disjunction )
+        return parseGroup('(?:', 'ignore', '(', 'normal');
+      }
+    }
+
+    function parseUnicodeSurrogatePairEscape(firstEscape) {
+      if (hasUnicodeFlag) {
+        var first, second;
+        if (firstEscape.kind == 'unicodeEscape' &&
+          (first = firstEscape.codePoint) >= 0xD800 && first <= 0xDBFF &&
+          current('\\') && next('u') ) {
+          var prevPos = pos;
+          pos++;
+          var secondEscape = parseClassEscape();
+          if (secondEscape.kind == 'unicodeEscape' &&
+            (second = secondEscape.codePoint) >= 0xDC00 && second <= 0xDFFF) {
+            // Unicode surrogate pair
+            firstEscape.range[1] = secondEscape.range[1];
+            firstEscape.codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+            firstEscape.type = 'value';
+            firstEscape.kind = 'unicodeCodePointEscape';
+            addRaw(firstEscape);
+          }
+          else {
+            pos = prevPos;
+          }
+        }
+      }
+      return firstEscape;
+    }
+
+    function parseClassEscape() {
+      return parseAtomEscape(true);
+    }
+
+    function parseAtomEscape(insideCharacterClass) {
+      // AtomEscape ::
+      //      DecimalEscape
+      //      CharacterEscape
+      //      CharacterClassEscape
+
+      var res;
+
+      res = parseDecimalEscape();
+      if (res) {
+        return res;
+      }
+
+      // For ClassEscape
+      if (insideCharacterClass) {
+        if (match('b')) {
+          // 15.10.2.19
+          // The production ClassEscape :: b evaluates by returning the
+          // CharSet containing the one character <BS> (Unicode value 0008).
+          return createEscaped('singleEscape', 0x0008, '\\b');
+        } else if (match('B')) {
+          throw SyntaxError('\\B not possible inside of CharacterClass');
+        }
+      }
+
+      res = parseCharacterEscape();
+
+      return res;
+    }
+
+
+    function parseDecimalEscape() {
+      // DecimalEscape ::
+      //      DecimalIntegerLiteral [lookahead ∉ DecimalDigit]
+      //      CharacterClassEscape :: one of d D s S w W
+
+      var res, match;
+
+      if (res = matchReg(/^(?!0)\d+/)) {
+        match = res[0];
+        var refIdx = parseInt(res[0], 10);
+        if (refIdx <= closedCaptureCounter) {
+          // If the number is smaller than the normal-groups found so
+          // far, then it is a reference...
+          return createReference(res[0]);
+        } else {
+          // ... otherwise it needs to be interpreted as a octal (if the
+          // number is in an octal format). If it is NOT octal format,
+          // then the slash is ignored and the number is matched later
+          // as normal characters.
+
+          // Reset the position again, as maybe only parts of the previous
+          // matched numbers are actual octal numbers. E.g. in '019' only
+          // the '01' should be matched.
+          incr(-res[0].length);
+          if (res = matchReg(/^[0-7]{1,3}/)) {
+            return createEscaped('octal', parseInt(res[0], 8), res[0], 1);
+          } else {
+            // If we end up here, we have a case like /\91/. Then the
+            // first slash is to be ignored and the 9 & 1 to be treated
+            // like ordinary characters. Create a character for the
+            // first number only here - other number-characters
+            // (if available) will be matched later.
+            res = createCharacter(matchReg(/^[89]/));
+            return updateRawStart(res, res.range[0] - 1);
+          }
+        }
+      }
+      // Only allow octal numbers in the following. All matched numbers start
+      // with a zero (if the do not, the previous if-branch is executed).
+      // If the number is not octal format and starts with zero (e.g. `091`)
+      // then only the zeros `0` is treated here and the `91` are ordinary
+      // characters.
+      // Example:
+      //   /\091/.exec('\091')[0].length === 3
+      else if (res = matchReg(/^[0-7]{1,3}/)) {
+        match = res[0];
+        if (/^0{1,3}$/.test(match)) {
+          // If they are all zeros, then only take the first one.
+          return createEscaped('null', 0x0000, '0', match.length + 1);
+        } else {
+          return createEscaped('octal', parseInt(match, 8), match, 1);
+        }
+      } else if (res = matchReg(/^[dDsSwW]/)) {
+        return createCharacterClassEscape(res[0]);
+      }
+      return false;
+    }
+
+    function parseCharacterEscape() {
+      // CharacterEscape ::
+      //      ControlEscape
+      //      c ControlLetter
+      //      HexEscapeSequence
+      //      UnicodeEscapeSequence
+      //      IdentityEscape
+
+      var res;
+      if (res = matchReg(/^[fnrtv]/)) {
+        // ControlEscape
+        var codePoint = 0;
+        switch (res[0]) {
+          case 't': codePoint = 0x009; break;
+          case 'n': codePoint = 0x00A; break;
+          case 'v': codePoint = 0x00B; break;
+          case 'f': codePoint = 0x00C; break;
+          case 'r': codePoint = 0x00D; break;
+        }
+        return createEscaped('singleEscape', codePoint, '\\' + res[0]);
+      } else if (res = matchReg(/^c([a-zA-Z])/)) {
+        // c ControlLetter
+        return createEscaped('controlLetter', res[1].charCodeAt(0) % 32, res[1], 2);
+      } else if (res = matchReg(/^x([0-9a-fA-F]{2})/)) {
+        // HexEscapeSequence
+        return createEscaped('hexadecimalEscape', parseInt(res[1], 16), res[1], 2);
+      } else if (res = matchReg(/^u([0-9a-fA-F]{4})/)) {
+        // UnicodeEscapeSequence
+        return parseUnicodeSurrogatePairEscape(
+          createEscaped('unicodeEscape', parseInt(res[1], 16), res[1], 2)
+        );
+      } else if (hasUnicodeFlag && (res = matchReg(/^u\{([0-9a-fA-F]{1,})\}/))) {
+        // RegExpUnicodeEscapeSequence (ES6 Unicode code point escape)
+        return createEscaped('unicodeCodePointEscape', parseInt(res[1], 16), res[1], 4);
+      } else {
+        // IdentityEscape
+        return parseIdentityEscape();
+      }
+    }
+
+    // Taken from the Esprima parser.
+    function isIdentifierPart(ch) {
+      // Generated by `tools/generate-identifier-regex.js`.
+      var NonAsciiIdentifierPart = new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]');
+
+      return (ch === 36) || (ch === 95) ||  // $ (dollar) and _ (underscore)
+        (ch >= 65 && ch <= 90) ||         // A..Z
+        (ch >= 97 && ch <= 122) ||        // a..z
+        (ch >= 48 && ch <= 57) ||         // 0..9
+        (ch === 92) ||                    // \ (backslash)
+        ((ch >= 0x80) && NonAsciiIdentifierPart.test(String.fromCharCode(ch)));
+    }
+
+    function parseIdentityEscape() {
+      // IdentityEscape ::
+      //      SourceCharacter but not IdentifierPart
+      //      <ZWJ>
+      //      <ZWNJ>
+
+      var ZWJ = '\u200C';
+      var ZWNJ = '\u200D';
+
+      var res;
+      var tmp;
+
+      if (!isIdentifierPart(lookahead())) {
+        tmp = incr();
+        return createEscaped('identifier', tmp.charCodeAt(0), tmp, 1);
+      }
+
+      if (match(ZWJ)) {
+        // <ZWJ>
+        return createEscaped('identifier', 0x200C, ZWJ);
+      } else if (match(ZWNJ)) {
+        // <ZWNJ>
+        return createEscaped('identifier', 0x200D, ZWNJ);
+      }
+
+      return null;
+    }
+
+    function parseCharacterClass() {
+      // CharacterClass ::
+      //      [ [lookahead ∉ {^}] ClassRanges ]
+      //      [ ^ ClassRanges ]
+
+      var res, from = pos;
+      if (res = matchReg(/^\[\^/)) {
+        res = parseClassRanges();
+        skip(']');
+        return createCharacterClass(res, true, from, pos);
+      } else if (match('[')) {
+        res = parseClassRanges();
+        skip(']');
+        return createCharacterClass(res, false, from, pos);
+      }
+
+      return null;
+    }
+
+    function parseClassRanges() {
+      // ClassRanges ::
+      //      [empty]
+      //      NonemptyClassRanges
+
+      var res;
+      if (current(']')) {
+        // Empty array means nothing insinde of the ClassRange.
+        return [];
+      } else {
+        res = parseNonemptyClassRanges();
+        if (!res) {
+          throw SyntaxError('nonEmptyClassRanges');
+        }
+        return res;
+      }
+    }
+
+    function parseHelperClassRanges(atom) {
+      var from, to, res;
+      if (current('-') && !next(']')) {
+        // ClassAtom - ClassAtom ClassRanges
+        skip('-');
+
+        res = parseClassAtom();
+        if (!res) {
+          throw SyntaxError('classAtom');
+        }
+        to = pos;
+        var classRanges = parseClassRanges();
+        if (!classRanges) {
+          throw SyntaxError('classRanges');
+        }
+        from = atom.range[0];
+        if (classRanges.type === 'empty') {
+          return [createClassRange(atom, res, from, to)];
+        }
+        return [createClassRange(atom, res, from, to)].concat(classRanges);
+      }
+
+      res = parseNonemptyClassRangesNoDash();
+      if (!res) {
+        throw SyntaxError('nonEmptyClassRangesNoDash');
+      }
+
+      return [atom].concat(res);
+    }
+
+    function parseNonemptyClassRanges() {
+      // NonemptyClassRanges ::
+      //      ClassAtom
+      //      ClassAtom NonemptyClassRangesNoDash
+      //      ClassAtom - ClassAtom ClassRanges
+
+      var atom = parseClassAtom();
+      if (!atom) {
+        throw SyntaxError('classAtom');
+      }
+
+      if (current(']')) {
+        // ClassAtom
+        return [atom];
+      }
+
+      // ClassAtom NonemptyClassRangesNoDash
+      // ClassAtom - ClassAtom ClassRanges
+      return parseHelperClassRanges(atom);
+    }
+
+    function parseNonemptyClassRangesNoDash() {
+      // NonemptyClassRangesNoDash ::
+      //      ClassAtom
+      //      ClassAtomNoDash NonemptyClassRangesNoDash
+      //      ClassAtomNoDash - ClassAtom ClassRanges
+
+      var res = parseClassAtom();
+      if (!res) {
+        throw SyntaxError('classAtom');
+      }
+      if (current(']')) {
+        //      ClassAtom
+        return res;
+      }
+
+      // ClassAtomNoDash NonemptyClassRangesNoDash
+      // ClassAtomNoDash - ClassAtom ClassRanges
+      return parseHelperClassRanges(res);
+    }
+
+    function parseClassAtom() {
+      // ClassAtom ::
+      //      -
+      //      ClassAtomNoDash
+      if (match('-')) {
+        return createCharacter('-');
+      } else {
+        return parseClassAtomNoDash();
+      }
+    }
+
+    function parseClassAtomNoDash() {
+      // ClassAtomNoDash ::
+      //      SourceCharacter but not one of \ or ] or -
+      //      \ ClassEscape
+
+      var res;
+      if (res = matchReg(/^[^\\\]-]/)) {
+        return createCharacter(res[0]);
+      } else if (match('\\')) {
+        res = parseClassEscape();
+        if (!res) {
+          throw SyntaxError('classEscape');
+        }
+
+        return parseUnicodeSurrogatePairEscape(res);
+      }
+    }
+
+    // Convert the input to a string and treat the empty string special.
+    str = String(str);
+    if (str === '') {
+      str = '(?:)';
+    }
+
+    var result = parseDisjunction();
+
+    if (result.range[1] !== str.length) {
+      throw SyntaxError('Could not parse entire input - got stuck: ' + str);
+    }
+
+    return result;
+  };
+
+  var regjsparser = {
+    parse: parse
+  };
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = regjsparser;
+  } else {
+    window.regjsparser = regjsparser;
+  }
+
+}());
+
+},{}],320:[function(require,module,exports){
+var generate = require('regjsgen').generate;
+var parse = require('regjsparser').parse;
+var regenerate = require('regenerate');
+var iuMappings = require('./data/iu-mappings.json');
+var ESCAPE_SETS = require('./data/character-class-escape-sets.js');
+
+function getCharacterClassEscapeSet(character) {
+	if (unicode) {
+		if (ignoreCase) {
+			return ESCAPE_SETS.UNICODE_IGNORE_CASE[character];
+		}
+		return ESCAPE_SETS.UNICODE[character];
+	}
+	return ESCAPE_SETS.REGULAR[character];
+}
+
+var object = {};
+var hasOwnProperty = object.hasOwnProperty;
+function has(object, property) {
+	return hasOwnProperty.call(object, property);
+}
+
+// Prepare a Regenerate set containing all code points, used for negative
+// character classes (if any).
+var UNICODE_SET = regenerate().addRange(0x0, 0x10FFFF);
+// Without the `u` flag, the range stops at 0xFFFF.
+// https://mths.be/es6#sec-pattern-semantics
+var BMP_SET = regenerate().addRange(0x0, 0xFFFF);
+
+// Prepare a Regenerate set containing all code points that are supposed to be
+// matched by `/./u`. https://mths.be/es6#sec-atom
+var DOT_SET_UNICODE = UNICODE_SET.clone() // all Unicode code points
+	.remove(
+		// minus `LineTerminator`s (https://mths.be/es6#sec-line-terminators):
+		0x000A, // Line Feed <LF>
+		0x000D, // Carriage Return <CR>
+		0x2028, // Line Separator <LS>
+		0x2029  // Paragraph Separator <PS>
+	);
+// Prepare a Regenerate set containing all code points that are supposed to be
+// matched by `/./` (only BMP code points).
+var DOT_SET = DOT_SET_UNICODE.clone()
+	.intersection(BMP_SET);
+
+// Add a range of code points + any case-folded code points in that range to a
+// set.
+regenerate.prototype.iuAddRange = function(min, max) {
+	var $this = this;
+	do {
+		var folded = caseFold(min);
+		if (folded) {
+			$this.add(folded);
+		}
+	} while (++min <= max);
+	return $this;
+};
+
+function assign(target, source) {
+	for (var key in source) {
+		// Note: `hasOwnProperty` is not needed here.
+		target[key] = source[key];
+	}
+}
+
+function update(item, pattern) {
+	// TODO: Test if memoizing `pattern` here is worth the effort.
+	if (!pattern) {
+		return;
+	}
+	var tree = parse(pattern, '');
+	switch (tree.type) {
+		case 'characterClass':
+		case 'group':
+		case 'value':
+			// No wrapping needed.
+			break;
+		default:
+			// Wrap the pattern in a non-capturing group.
+			tree = wrap(tree, pattern);
+	}
+	assign(item, tree);
+}
+
+function wrap(tree, pattern) {
+	// Wrap the pattern in a non-capturing group.
+	return {
+		'type': 'group',
+		'behavior': 'ignore',
+		'body': [tree],
+		'raw': '(?:' + pattern + ')'
+	};
+}
+
+function caseFold(codePoint) {
+	return has(iuMappings, codePoint) ? iuMappings[codePoint] : false;
+}
+
+var ignoreCase = false;
+var unicode = false;
+function processCharacterClass(characterClassItem) {
+	var set = regenerate();
+	var body = characterClassItem.body.forEach(function(item) {
+		switch (item.type) {
+			case 'value':
+				set.add(item.codePoint);
+				if (ignoreCase && unicode) {
+					var folded = caseFold(item.codePoint);
+					if (folded) {
+						set.add(folded);
+					}
+				}
+				break;
+			case 'characterClassRange':
+				var min = item.min.codePoint;
+				var max = item.max.codePoint;
+				set.addRange(min, max);
+				if (ignoreCase && unicode) {
+					set.iuAddRange(min, max);
+				}
+				break;
+			case 'characterClassEscape':
+				set.add(getCharacterClassEscapeSet(item.value));
+				break;
+			// The `default` clause is only here as a safeguard; it should never be
+			// reached. Code coverage tools should ignore it.
+			/* istanbul ignore next */
+			default:
+				throw Error('Unknown term type: ' + item.type);
+		}
+	});
+	if (characterClassItem.negative) {
+		set = (unicode ? UNICODE_SET : BMP_SET).clone().remove(set);
+	}
+	update(characterClassItem, set.toString());
+	return characterClassItem;
+}
+
+function processTerm(item) {
+	switch (item.type) {
+		case 'dot':
+			update(
+				item,
+				(unicode ? DOT_SET_UNICODE : DOT_SET).toString()
+			);
+			break;
+		case 'characterClass':
+			item = processCharacterClass(item);
+			break;
+		case 'characterClassEscape':
+			update(
+				item,
+				getCharacterClassEscapeSet(item.value).toString()
+			);
+			break;
+		case 'alternative':
+		case 'disjunction':
+		case 'group':
+		case 'quantifier':
+			item.body = item.body.map(processTerm);
+			break;
+		case 'value':
+			var codePoint = item.codePoint;
+			var set = regenerate(codePoint);
+			if (ignoreCase && unicode) {
+				var folded = caseFold(codePoint);
+				if (folded) {
+					set.add(folded);
+				}
+			}
+			update(item, set.toString());
+			break;
+		case 'anchor':
+		case 'empty':
+		case 'group':
+		case 'reference':
+			// Nothing to do here.
+			break;
+		// The `default` clause is only here as a safeguard; it should never be
+		// reached. Code coverage tools should ignore it.
+		/* istanbul ignore next */
+		default:
+			throw Error('Unknown term type: ' + item.type);
+	}
+	return item;
+};
+
+module.exports = function(pattern, flags) {
+	var tree = parse(pattern, flags);
+	ignoreCase = flags ? flags.indexOf('i') > -1 : false;
+	unicode = flags ? flags.indexOf('u') > -1 : false;
+	assign(tree, processTerm(tree));
+	return generate(tree);
+};
+
+},{"./data/character-class-escape-sets.js":315,"./data/iu-mappings.json":316,"regenerate":317,"regjsgen":318,"regjsparser":319}],321:[function(require,module,exports){
+'use strict';
+var isFinite = require('is-finite');
+
+module.exports = function (str, n) {
+	if (typeof str !== 'string') {
+		throw new TypeError('Expected a string as the first argument');
+	}
+
+	if (n < 0 || !isFinite(n)) {
+		throw new TypeError('Expected a finite positive number');
+	}
+
+	var ret = '';
+
+	do {
+		if (n & 1) {
+			ret += str;
+		}
+
+		str += str;
+	} while (n = n >> 1);
+
+	return ret;
+};
+
+},{"is-finite":322}],322:[function(require,module,exports){
+arguments[4][185][0].apply(exports,arguments)
+},{"dup":185}],323:[function(require,module,exports){
+'use strict';
+module.exports = /^#!.*/;
+
+},{}],324:[function(require,module,exports){
+'use strict';
+module.exports = function (str) {
+	var isExtendedLengthPath = /^\\\\\?\\/.test(str);
+	var hasNonAscii = /[^\x00-\x80]+/.test(str);
+
+	if (isExtendedLengthPath || hasNonAscii) {
+		return str;
+	}
+
+	return str.replace(/\\/g, '/');
+};
+
+},{}],325:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+module.exports = function (val) {
+	var base64 = new Buffer(JSON.stringify(val)).toString('base64');
+	return '//# sourceMappingURL=data:application/json;base64,' + base64;
+};
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":139}],326:[function(require,module,exports){
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./source-map/source-node').SourceNode;
+
+},{"./source-map/source-map-consumer":332,"./source-map/source-map-generator":333,"./source-map/source-node":334}],327:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var util = require('./util');
+
+  /**
+   * A data structure which is a combination of an array and a set. Adding a new
+   * member is O(1), testing for membership is O(1), and finding the index of an
+   * element is O(1). Removing elements from the set is not supported. Only
+   * strings are supported for membership.
+   */
+  function ArraySet() {
+    this._array = [];
+    this._set = {};
+  }
+
+  /**
+   * Static method for creating ArraySet instances from an existing array.
+   */
+  ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+    var set = new ArraySet();
+    for (var i = 0, len = aArray.length; i < len; i++) {
+      set.add(aArray[i], aAllowDuplicates);
+    }
+    return set;
+  };
+
+  /**
+   * Add the given string to this set.
+   *
+   * @param String aStr
+   */
+  ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+    var isDuplicate = this.has(aStr);
+    var idx = this._array.length;
+    if (!isDuplicate || aAllowDuplicates) {
+      this._array.push(aStr);
+    }
+    if (!isDuplicate) {
+      this._set[util.toSetString(aStr)] = idx;
+    }
+  };
+
+  /**
+   * Is the given string a member of this set?
+   *
+   * @param String aStr
+   */
+  ArraySet.prototype.has = function ArraySet_has(aStr) {
+    return Object.prototype.hasOwnProperty.call(this._set,
+                                                util.toSetString(aStr));
+  };
+
+  /**
+   * What is the index of the given string in the array?
+   *
+   * @param String aStr
+   */
+  ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+    if (this.has(aStr)) {
+      return this._set[util.toSetString(aStr)];
+    }
+    throw new Error('"' + aStr + '" is not in the set.');
+  };
+
+  /**
+   * What is the element at the given index?
+   *
+   * @param Number aIdx
+   */
+  ArraySet.prototype.at = function ArraySet_at(aIdx) {
+    if (aIdx >= 0 && aIdx < this._array.length) {
+      return this._array[aIdx];
+    }
+    throw new Error('No element indexed by ' + aIdx);
+  };
+
+  /**
+   * Returns the array representation of this set (which has the proper indices
+   * indicated by indexOf). Note that this is a copy of the internal array used
+   * for storing the members so that no one can mess with internal state.
+   */
+  ArraySet.prototype.toArray = function ArraySet_toArray() {
+    return this._array.slice();
+  };
+
+  exports.ArraySet = ArraySet;
+
+});
+
+},{"./util":335,"amdefine":336}],328:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *  * Neither the name of Google Inc. nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var base64 = require('./base64');
+
+  // A single base 64 digit can contain 6 bits of data. For the base 64 variable
+  // length quantities we use in the source map spec, the first bit is the sign,
+  // the next four bits are the actual value, and the 6th bit is the
+  // continuation bit. The continuation bit tells us whether there are more
+  // digits in this value following this digit.
+  //
+  //   Continuation
+  //   |    Sign
+  //   |    |
+  //   V    V
+  //   101011
+
+  var VLQ_BASE_SHIFT = 5;
+
+  // binary: 100000
+  var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+  // binary: 011111
+  var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+  // binary: 100000
+  var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+  /**
+   * Converts from a two-complement value to a value where the sign bit is
+   * placed in the least significant bit.  For example, as decimals:
+   *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+   *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+   */
+  function toVLQSigned(aValue) {
+    return aValue < 0
+      ? ((-aValue) << 1) + 1
+      : (aValue << 1) + 0;
+  }
+
+  /**
+   * Converts to a two-complement value from a value where the sign bit is
+   * placed in the least significant bit.  For example, as decimals:
+   *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+   *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+   */
+  function fromVLQSigned(aValue) {
+    var isNegative = (aValue & 1) === 1;
+    var shifted = aValue >> 1;
+    return isNegative
+      ? -shifted
+      : shifted;
+  }
+
+  /**
+   * Returns the base 64 VLQ encoded value.
+   */
+  exports.encode = function base64VLQ_encode(aValue) {
+    var encoded = "";
+    var digit;
+
+    var vlq = toVLQSigned(aValue);
+
+    do {
+      digit = vlq & VLQ_BASE_MASK;
+      vlq >>>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        // There are still more digits in this value, so we must make sure the
+        // continuation bit is marked.
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64.encode(digit);
+    } while (vlq > 0);
+
+    return encoded;
+  };
+
+  /**
+   * Decodes the next base 64 VLQ value from the given string and returns the
+   * value and the rest of the string via the out parameter.
+   */
+  exports.decode = function base64VLQ_decode(aStr, aOutParam) {
+    var i = 0;
+    var strLen = aStr.length;
+    var result = 0;
+    var shift = 0;
+    var continuation, digit;
+
+    do {
+      if (i >= strLen) {
+        throw new Error("Expected more digits in base 64 VLQ value.");
+      }
+      digit = base64.decode(aStr.charAt(i++));
+      continuation = !!(digit & VLQ_CONTINUATION_BIT);
+      digit &= VLQ_BASE_MASK;
+      result = result + (digit << shift);
+      shift += VLQ_BASE_SHIFT;
+    } while (continuation);
+
+    aOutParam.value = fromVLQSigned(result);
+    aOutParam.rest = aStr.slice(i);
+  };
+
+});
+
+},{"./base64":329,"amdefine":336}],329:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var charToIntMap = {};
+  var intToCharMap = {};
+
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+    .split('')
+    .forEach(function (ch, index) {
+      charToIntMap[ch] = index;
+      intToCharMap[index] = ch;
+    });
+
+  /**
+   * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+   */
+  exports.encode = function base64_encode(aNumber) {
+    if (aNumber in intToCharMap) {
+      return intToCharMap[aNumber];
+    }
+    throw new TypeError("Must be between 0 and 63: " + aNumber);
+  };
+
+  /**
+   * Decode a single base 64 digit to an integer.
+   */
+  exports.decode = function base64_decode(aChar) {
+    if (aChar in charToIntMap) {
+      return charToIntMap[aChar];
+    }
+    throw new TypeError("Not a valid base 64 digit: " + aChar);
+  };
+
+});
+
+},{"amdefine":336}],330:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  /**
+   * Recursive implementation of binary search.
+   *
+   * @param aLow Indices here and lower do not contain the needle.
+   * @param aHigh Indices here and higher do not contain the needle.
+   * @param aNeedle The element being searched for.
+   * @param aHaystack The non-empty array being searched.
+   * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+   */
+  function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
+    // This function terminates when one of the following is true:
+    //
+    //   1. We find the exact element we are looking for.
+    //
+    //   2. We did not find the exact element, but we can return the index of
+    //      the next closest element that is less than that element.
+    //
+    //   3. We did not find the exact element, and there is no next-closest
+    //      element which is less than the one we are searching for, so we
+    //      return -1.
+    var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+    var cmp = aCompare(aNeedle, aHaystack[mid], true);
+    if (cmp === 0) {
+      // Found the element we are looking for.
+      return mid;
+    }
+    else if (cmp > 0) {
+      // aHaystack[mid] is greater than our needle.
+      if (aHigh - mid > 1) {
+        // The element is in the upper half.
+        return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
+      }
+      // We did not find an exact match, return the next closest one
+      // (termination case 2).
+      return mid;
+    }
+    else {
+      // aHaystack[mid] is less than our needle.
+      if (mid - aLow > 1) {
+        // The element is in the lower half.
+        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
+      }
+      // The exact needle element was not found in this haystack. Determine if
+      // we are in termination case (2) or (3) and return the appropriate thing.
+      return aLow < 0 ? -1 : aLow;
+    }
+  }
+
+  /**
+   * This is an implementation of binary search which will always try and return
+   * the index of next lowest value checked if there is no exact hit. This is
+   * because mappings between original and generated line/col pairs are single
+   * points, and there is an implicit region between each of them, so a miss
+   * just means that you aren't on the very start of a region.
+   *
+   * @param aNeedle The element you are looking for.
+   * @param aHaystack The array that is being searched.
+   * @param aCompare A function which takes the needle and an element in the
+   *     array and returns -1, 0, or 1 depending on whether the needle is less
+   *     than, equal to, or greater than the element, respectively.
+   */
+  exports.search = function search(aNeedle, aHaystack, aCompare) {
+    if (aHaystack.length === 0) {
+      return -1;
+    }
+    return recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
+  };
+
+});
+
+},{"amdefine":336}],331:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2014 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var util = require('./util');
+
+  /**
+   * Determine whether mappingB is after mappingA with respect to generated
+   * position.
+   */
+  function generatedPositionAfter(mappingA, mappingB) {
+    // Optimized for most common case
+    var lineA = mappingA.generatedLine;
+    var lineB = mappingB.generatedLine;
+    var columnA = mappingA.generatedColumn;
+    var columnB = mappingB.generatedColumn;
+    return lineB > lineA || lineB == lineA && columnB >= columnA ||
+           util.compareByGeneratedPositions(mappingA, mappingB) <= 0;
+  }
+
+  /**
+   * A data structure to provide a sorted view of accumulated mappings in a
+   * performance conscious manner. It trades a neglibable overhead in general
+   * case for a large speedup in case of mappings being added in order.
+   */
+  function MappingList() {
+    this._array = [];
+    this._sorted = true;
+    // Serves as infimum
+    this._last = {generatedLine: -1, generatedColumn: 0};
+  }
+
+  /**
+   * Iterate through internal items. This method takes the same arguments that
+   * `Array.prototype.forEach` takes.
+   *
+   * NOTE: The order of the mappings is NOT guaranteed.
+   */
+  MappingList.prototype.unsortedForEach =
+    function MappingList_forEach(aCallback, aThisArg) {
+      this._array.forEach(aCallback, aThisArg);
+    };
+
+  /**
+   * Add the given source mapping.
+   *
+   * @param Object aMapping
+   */
+  MappingList.prototype.add = function MappingList_add(aMapping) {
+    var mapping;
+    if (generatedPositionAfter(this._last, aMapping)) {
+      this._last = aMapping;
+      this._array.push(aMapping);
+    } else {
+      this._sorted = false;
+      this._array.push(aMapping);
+    }
+  };
+
+  /**
+   * Returns the flat, sorted array of mappings. The mappings are sorted by
+   * generated position.
+   *
+   * WARNING: This method returns internal data without copying, for
+   * performance. The return value must NOT be mutated, and should be treated as
+   * an immutable borrow. If you want to take ownership, you must make your own
+   * copy.
+   */
+  MappingList.prototype.toArray = function MappingList_toArray() {
+    if (!this._sorted) {
+      this._array.sort(util.compareByGeneratedPositions);
+      this._sorted = true;
+    }
+    return this._array;
+  };
+
+  exports.MappingList = MappingList;
+
+});
+
+},{"./util":335,"amdefine":336}],332:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var util = require('./util');
+  var binarySearch = require('./binary-search');
+  var ArraySet = require('./array-set').ArraySet;
+  var base64VLQ = require('./base64-vlq');
+
+  /**
+   * A SourceMapConsumer instance represents a parsed source map which we can
+   * query for information about the original file positions by giving it a file
+   * position in the generated source.
+   *
+   * The only parameter is the raw source map (either as a JSON string, or
+   * already parsed to an object). According to the spec, source maps have the
+   * following attributes:
+   *
+   *   - version: Which version of the source map spec this map is following.
+   *   - sources: An array of URLs to the original source files.
+   *   - names: An array of identifiers which can be referrenced by individual mappings.
+   *   - sourceRoot: Optional. The URL root from which all sources are relative.
+   *   - sourcesContent: Optional. An array of contents of the original source files.
+   *   - mappings: A string of base64 VLQs which contain the actual mappings.
+   *   - file: Optional. The generated file this source map is associated with.
+   *
+   * Here is an example source map, taken from the source map spec[0]:
+   *
+   *     {
+   *       version : 3,
+   *       file: "out.js",
+   *       sourceRoot : "",
+   *       sources: ["foo.js", "bar.js"],
+   *       names: ["src", "maps", "are", "fun"],
+   *       mappings: "AA,AB;;ABCDE;"
+   *     }
+   *
+   * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+   */
+  function SourceMapConsumer(aSourceMap) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === 'string') {
+      sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+    }
+
+    var version = util.getArg(sourceMap, 'version');
+    var sources = util.getArg(sourceMap, 'sources');
+    // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
+    // requires the array) to play nice here.
+    var names = util.getArg(sourceMap, 'names', []);
+    var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+    var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+    var mappings = util.getArg(sourceMap, 'mappings');
+    var file = util.getArg(sourceMap, 'file', null);
+
+    // Once again, Sass deviates from the spec and supplies the version as a
+    // string rather than a number, so we use loose equality checking here.
+    if (version != this._version) {
+      throw new Error('Unsupported version: ' + version);
+    }
+
+    // Some source maps produce relative source paths like "./foo.js" instead of
+    // "foo.js".  Normalize these first so that future comparisons will succeed.
+    // See bugzil.la/1090768.
+    sources = sources.map(util.normalize);
+
+    // Pass `true` below to allow duplicate names and sources. While source maps
+    // are intended to be compressed and deduplicated, the TypeScript compiler
+    // sometimes generates source maps with duplicates in them. See Github issue
+    // #72 and bugzil.la/889492.
+    this._names = ArraySet.fromArray(names, true);
+    this._sources = ArraySet.fromArray(sources, true);
+
+    this.sourceRoot = sourceRoot;
+    this.sourcesContent = sourcesContent;
+    this._mappings = mappings;
+    this.file = file;
+  }
+
+  /**
+   * Create a SourceMapConsumer from a SourceMapGenerator.
+   *
+   * @param SourceMapGenerator aSourceMap
+   *        The source map that will be consumed.
+   * @returns SourceMapConsumer
+   */
+  SourceMapConsumer.fromSourceMap =
+    function SourceMapConsumer_fromSourceMap(aSourceMap) {
+      var smc = Object.create(SourceMapConsumer.prototype);
+
+      smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+      smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+      smc.sourceRoot = aSourceMap._sourceRoot;
+      smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
+                                                              smc.sourceRoot);
+      smc.file = aSourceMap._file;
+
+      smc.__generatedMappings = aSourceMap._mappings.toArray().slice();
+      smc.__originalMappings = aSourceMap._mappings.toArray().slice()
+        .sort(util.compareByOriginalPositions);
+
+      return smc;
+    };
+
+  /**
+   * The version of the source mapping spec that we are consuming.
+   */
+  SourceMapConsumer.prototype._version = 3;
+
+  /**
+   * The list of original sources.
+   */
+  Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
+    get: function () {
+      return this._sources.toArray().map(function (s) {
+        return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
+      }, this);
+    }
+  });
+
+  // `__generatedMappings` and `__originalMappings` are arrays that hold the
+  // parsed mapping coordinates from the source map's "mappings" attribute. They
+  // are lazily instantiated, accessed via the `_generatedMappings` and
+  // `_originalMappings` getters respectively, and we only parse the mappings
+  // and create these arrays once queried for a source location. We jump through
+  // these hoops because there can be many thousands of mappings, and parsing
+  // them is expensive, so we only want to do it if we must.
+  //
+  // Each object in the arrays is of the form:
+  //
+  //     {
+  //       generatedLine: The line number in the generated code,
+  //       generatedColumn: The column number in the generated code,
+  //       source: The path to the original source file that generated this
+  //               chunk of code,
+  //       originalLine: The line number in the original source that
+  //                     corresponds to this chunk of generated code,
+  //       originalColumn: The column number in the original source that
+  //                       corresponds to this chunk of generated code,
+  //       name: The name of the original symbol which generated this chunk of
+  //             code.
+  //     }
+  //
+  // All properties except for `generatedLine` and `generatedColumn` can be
+  // `null`.
+  //
+  // `_generatedMappings` is ordered by the generated positions.
+  //
+  // `_originalMappings` is ordered by the original positions.
+
+  SourceMapConsumer.prototype.__generatedMappings = null;
+  Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
+    get: function () {
+      if (!this.__generatedMappings) {
+        this.__generatedMappings = [];
+        this.__originalMappings = [];
+        this._parseMappings(this._mappings, this.sourceRoot);
+      }
+
+      return this.__generatedMappings;
+    }
+  });
+
+  SourceMapConsumer.prototype.__originalMappings = null;
+  Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
+    get: function () {
+      if (!this.__originalMappings) {
+        this.__generatedMappings = [];
+        this.__originalMappings = [];
+        this._parseMappings(this._mappings, this.sourceRoot);
+      }
+
+      return this.__originalMappings;
+    }
+  });
+
+  SourceMapConsumer.prototype._nextCharIsMappingSeparator =
+    function SourceMapConsumer_nextCharIsMappingSeparator(aStr) {
+      var c = aStr.charAt(0);
+      return c === ";" || c === ",";
+    };
+
+  /**
+   * Parse the mappings in a string in to a data structure which we can easily
+   * query (the ordered arrays in the `this.__generatedMappings` and
+   * `this.__originalMappings` properties).
+   */
+  SourceMapConsumer.prototype._parseMappings =
+    function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+      var generatedLine = 1;
+      var previousGeneratedColumn = 0;
+      var previousOriginalLine = 0;
+      var previousOriginalColumn = 0;
+      var previousSource = 0;
+      var previousName = 0;
+      var str = aStr;
+      var temp = {};
+      var mapping;
+
+      while (str.length > 0) {
+        if (str.charAt(0) === ';') {
+          generatedLine++;
+          str = str.slice(1);
+          previousGeneratedColumn = 0;
+        }
+        else if (str.charAt(0) === ',') {
+          str = str.slice(1);
+        }
+        else {
+          mapping = {};
+          mapping.generatedLine = generatedLine;
+
+          // Generated column.
+          base64VLQ.decode(str, temp);
+          mapping.generatedColumn = previousGeneratedColumn + temp.value;
+          previousGeneratedColumn = mapping.generatedColumn;
+          str = temp.rest;
+
+          if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
+            // Original source.
+            base64VLQ.decode(str, temp);
+            mapping.source = this._sources.at(previousSource + temp.value);
+            previousSource += temp.value;
+            str = temp.rest;
+            if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
+              throw new Error('Found a source, but no line and column');
+            }
+
+            // Original line.
+            base64VLQ.decode(str, temp);
+            mapping.originalLine = previousOriginalLine + temp.value;
+            previousOriginalLine = mapping.originalLine;
+            // Lines are stored 0-based
+            mapping.originalLine += 1;
+            str = temp.rest;
+            if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
+              throw new Error('Found a source and line, but no column');
+            }
+
+            // Original column.
+            base64VLQ.decode(str, temp);
+            mapping.originalColumn = previousOriginalColumn + temp.value;
+            previousOriginalColumn = mapping.originalColumn;
+            str = temp.rest;
+
+            if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
+              // Original name.
+              base64VLQ.decode(str, temp);
+              mapping.name = this._names.at(previousName + temp.value);
+              previousName += temp.value;
+              str = temp.rest;
+            }
+          }
+
+          this.__generatedMappings.push(mapping);
+          if (typeof mapping.originalLine === 'number') {
+            this.__originalMappings.push(mapping);
+          }
+        }
+      }
+
+      this.__generatedMappings.sort(util.compareByGeneratedPositions);
+      this.__originalMappings.sort(util.compareByOriginalPositions);
+    };
+
+  /**
+   * Find the mapping that best matches the hypothetical "needle" mapping that
+   * we are searching for in the given "haystack" of mappings.
+   */
+  SourceMapConsumer.prototype._findMapping =
+    function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+                                           aColumnName, aComparator) {
+      // To return the position we are searching for, we must first find the
+      // mapping for the given position and then return the opposite position it
+      // points to. Because the mappings are sorted, we can use binary search to
+      // find the best mapping.
+
+      if (aNeedle[aLineName] <= 0) {
+        throw new TypeError('Line must be greater than or equal to 1, got '
+                            + aNeedle[aLineName]);
+      }
+      if (aNeedle[aColumnName] < 0) {
+        throw new TypeError('Column must be greater than or equal to 0, got '
+                            + aNeedle[aColumnName]);
+      }
+
+      return binarySearch.search(aNeedle, aMappings, aComparator);
+    };
+
+  /**
+   * Compute the last column for each generated mapping. The last column is
+   * inclusive.
+   */
+  SourceMapConsumer.prototype.computeColumnSpans =
+    function SourceMapConsumer_computeColumnSpans() {
+      for (var index = 0; index < this._generatedMappings.length; ++index) {
+        var mapping = this._generatedMappings[index];
+
+        // Mappings do not contain a field for the last generated columnt. We
+        // can come up with an optimistic estimate, however, by assuming that
+        // mappings are contiguous (i.e. given two consecutive mappings, the
+        // first mapping ends where the second one starts).
+        if (index + 1 < this._generatedMappings.length) {
+          var nextMapping = this._generatedMappings[index + 1];
+
+          if (mapping.generatedLine === nextMapping.generatedLine) {
+            mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+            continue;
+          }
+        }
+
+        // The last mapping for each line spans the entire line.
+        mapping.lastGeneratedColumn = Infinity;
+      }
+    };
+
+  /**
+   * Returns the original source, line, and column information for the generated
+   * source's line and column positions provided. The only argument is an object
+   * with the following properties:
+   *
+   *   - line: The line number in the generated source.
+   *   - column: The column number in the generated source.
+   *
+   * and an object is returned with the following properties:
+   *
+   *   - source: The original source file, or null.
+   *   - line: The line number in the original source, or null.
+   *   - column: The column number in the original source, or null.
+   *   - name: The original identifier, or null.
+   */
+  SourceMapConsumer.prototype.originalPositionFor =
+    function SourceMapConsumer_originalPositionFor(aArgs) {
+      var needle = {
+        generatedLine: util.getArg(aArgs, 'line'),
+        generatedColumn: util.getArg(aArgs, 'column')
+      };
+
+      var index = this._findMapping(needle,
+                                    this._generatedMappings,
+                                    "generatedLine",
+                                    "generatedColumn",
+                                    util.compareByGeneratedPositions);
+
+      if (index >= 0) {
+        var mapping = this._generatedMappings[index];
+
+        if (mapping.generatedLine === needle.generatedLine) {
+          var source = util.getArg(mapping, 'source', null);
+          if (source != null && this.sourceRoot != null) {
+            source = util.join(this.sourceRoot, source);
+          }
+          return {
+            source: source,
+            line: util.getArg(mapping, 'originalLine', null),
+            column: util.getArg(mapping, 'originalColumn', null),
+            name: util.getArg(mapping, 'name', null)
+          };
+        }
+      }
+
+      return {
+        source: null,
+        line: null,
+        column: null,
+        name: null
+      };
+    };
+
+  /**
+   * Returns the original source content. The only argument is the url of the
+   * original source file. Returns null if no original source content is
+   * availible.
+   */
+  SourceMapConsumer.prototype.sourceContentFor =
+    function SourceMapConsumer_sourceContentFor(aSource) {
+      if (!this.sourcesContent) {
+        return null;
+      }
+
+      if (this.sourceRoot != null) {
+        aSource = util.relative(this.sourceRoot, aSource);
+      }
+
+      if (this._sources.has(aSource)) {
+        return this.sourcesContent[this._sources.indexOf(aSource)];
+      }
+
+      var url;
+      if (this.sourceRoot != null
+          && (url = util.urlParse(this.sourceRoot))) {
+        // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+        // many users. We can help them out when they expect file:// URIs to
+        // behave like it would if they were running a local HTTP server. See
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+        var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
+        if (url.scheme == "file"
+            && this._sources.has(fileUriAbsPath)) {
+          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+        }
+
+        if ((!url.path || url.path == "/")
+            && this._sources.has("/" + aSource)) {
+          return this.sourcesContent[this._sources.indexOf("/" + aSource)];
+        }
+      }
+
+      throw new Error('"' + aSource + '" is not in the SourceMap.');
+    };
+
+  /**
+   * Returns the generated line and column information for the original source,
+   * line, and column positions provided. The only argument is an object with
+   * the following properties:
+   *
+   *   - source: The filename of the original source.
+   *   - line: The line number in the original source.
+   *   - column: The column number in the original source.
+   *
+   * and an object is returned with the following properties:
+   *
+   *   - line: The line number in the generated source, or null.
+   *   - column: The column number in the generated source, or null.
+   */
+  SourceMapConsumer.prototype.generatedPositionFor =
+    function SourceMapConsumer_generatedPositionFor(aArgs) {
+      var needle = {
+        source: util.getArg(aArgs, 'source'),
+        originalLine: util.getArg(aArgs, 'line'),
+        originalColumn: util.getArg(aArgs, 'column')
+      };
+
+      if (this.sourceRoot != null) {
+        needle.source = util.relative(this.sourceRoot, needle.source);
+      }
+
+      var index = this._findMapping(needle,
+                                    this._originalMappings,
+                                    "originalLine",
+                                    "originalColumn",
+                                    util.compareByOriginalPositions);
+
+      if (index >= 0) {
+        var mapping = this._originalMappings[index];
+
+        return {
+          line: util.getArg(mapping, 'generatedLine', null),
+          column: util.getArg(mapping, 'generatedColumn', null),
+          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+        };
+      }
+
+      return {
+        line: null,
+        column: null,
+        lastColumn: null
+      };
+    };
+
+  /**
+   * Returns all generated line and column information for the original source
+   * and line provided. The only argument is an object with the following
+   * properties:
+   *
+   *   - source: The filename of the original source.
+   *   - line: The line number in the original source.
+   *
+   * and an array of objects is returned, each with the following properties:
+   *
+   *   - line: The line number in the generated source, or null.
+   *   - column: The column number in the generated source, or null.
+   */
+  SourceMapConsumer.prototype.allGeneratedPositionsFor =
+    function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+      // When there is no exact match, SourceMapConsumer.prototype._findMapping
+      // returns the index of the closest mapping less than the needle. By
+      // setting needle.originalColumn to Infinity, we thus find the last
+      // mapping for the given line, provided such a mapping exists.
+      var needle = {
+        source: util.getArg(aArgs, 'source'),
+        originalLine: util.getArg(aArgs, 'line'),
+        originalColumn: Infinity
+      };
+
+      if (this.sourceRoot != null) {
+        needle.source = util.relative(this.sourceRoot, needle.source);
+      }
+
+      var mappings = [];
+
+      var index = this._findMapping(needle,
+                                    this._originalMappings,
+                                    "originalLine",
+                                    "originalColumn",
+                                    util.compareByOriginalPositions);
+      if (index >= 0) {
+        var mapping = this._originalMappings[index];
+
+        while (mapping && mapping.originalLine === needle.originalLine) {
+          mappings.push({
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
+            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+          });
+
+          mapping = this._originalMappings[--index];
+        }
+      }
+
+      return mappings.reverse();
+    };
+
+  SourceMapConsumer.GENERATED_ORDER = 1;
+  SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+  /**
+   * Iterate over each mapping between an original source/line/column and a
+   * generated line/column in this source map.
+   *
+   * @param Function aCallback
+   *        The function that is called with each mapping.
+   * @param Object aContext
+   *        Optional. If specified, this object will be the value of `this` every
+   *        time that `aCallback` is called.
+   * @param aOrder
+   *        Either `SourceMapConsumer.GENERATED_ORDER` or
+   *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+   *        iterate over the mappings sorted by the generated file's line/column
+   *        order or the original's source/line/column order, respectively. Defaults to
+   *        `SourceMapConsumer.GENERATED_ORDER`.
+   */
+  SourceMapConsumer.prototype.eachMapping =
+    function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+      var context = aContext || null;
+      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+      var mappings;
+      switch (order) {
+      case SourceMapConsumer.GENERATED_ORDER:
+        mappings = this._generatedMappings;
+        break;
+      case SourceMapConsumer.ORIGINAL_ORDER:
+        mappings = this._originalMappings;
+        break;
+      default:
+        throw new Error("Unknown order of iteration.");
+      }
+
+      var sourceRoot = this.sourceRoot;
+      mappings.map(function (mapping) {
+        var source = mapping.source;
+        if (source != null && sourceRoot != null) {
+          source = util.join(sourceRoot, source);
+        }
+        return {
+          source: source,
+          generatedLine: mapping.generatedLine,
+          generatedColumn: mapping.generatedColumn,
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name: mapping.name
+        };
+      }).forEach(aCallback, context);
+    };
+
+  exports.SourceMapConsumer = SourceMapConsumer;
+
+});
+
+},{"./array-set":327,"./base64-vlq":328,"./binary-search":330,"./util":335,"amdefine":336}],333:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var base64VLQ = require('./base64-vlq');
+  var util = require('./util');
+  var ArraySet = require('./array-set').ArraySet;
+  var MappingList = require('./mapping-list').MappingList;
+
+  /**
+   * An instance of the SourceMapGenerator represents a source map which is
+   * being built incrementally. You may pass an object with the following
+   * properties:
+   *
+   *   - file: The filename of the generated source.
+   *   - sourceRoot: A root for all relative URLs in this source map.
+   */
+  function SourceMapGenerator(aArgs) {
+    if (!aArgs) {
+      aArgs = {};
+    }
+    this._file = util.getArg(aArgs, 'file', null);
+    this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+    this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
+    this._sources = new ArraySet();
+    this._names = new ArraySet();
+    this._mappings = new MappingList();
+    this._sourcesContents = null;
+  }
+
+  SourceMapGenerator.prototype._version = 3;
+
+  /**
+   * Creates a new SourceMapGenerator based on a SourceMapConsumer
+   *
+   * @param aSourceMapConsumer The SourceMap.
+   */
+  SourceMapGenerator.fromSourceMap =
+    function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
+      var sourceRoot = aSourceMapConsumer.sourceRoot;
+      var generator = new SourceMapGenerator({
+        file: aSourceMapConsumer.file,
+        sourceRoot: sourceRoot
+      });
+      aSourceMapConsumer.eachMapping(function (mapping) {
+        var newMapping = {
+          generated: {
+            line: mapping.generatedLine,
+            column: mapping.generatedColumn
+          }
+        };
+
+        if (mapping.source != null) {
+          newMapping.source = mapping.source;
+          if (sourceRoot != null) {
+            newMapping.source = util.relative(sourceRoot, newMapping.source);
+          }
+
+          newMapping.original = {
+            line: mapping.originalLine,
+            column: mapping.originalColumn
+          };
+
+          if (mapping.name != null) {
+            newMapping.name = mapping.name;
+          }
+        }
+
+        generator.addMapping(newMapping);
+      });
+      aSourceMapConsumer.sources.forEach(function (sourceFile) {
+        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+        if (content != null) {
+          generator.setSourceContent(sourceFile, content);
+        }
+      });
+      return generator;
+    };
+
+  /**
+   * Add a single mapping from original source line and column to the generated
+   * source's line and column for this source map being created. The mapping
+   * object should have the following properties:
+   *
+   *   - generated: An object with the generated line and column positions.
+   *   - original: An object with the original line and column positions.
+   *   - source: The original source file (relative to the sourceRoot).
+   *   - name: An optional original token name for this mapping.
+   */
+  SourceMapGenerator.prototype.addMapping =
+    function SourceMapGenerator_addMapping(aArgs) {
+      var generated = util.getArg(aArgs, 'generated');
+      var original = util.getArg(aArgs, 'original', null);
+      var source = util.getArg(aArgs, 'source', null);
+      var name = util.getArg(aArgs, 'name', null);
+
+      if (!this._skipValidation) {
+        this._validateMapping(generated, original, source, name);
+      }
+
+      if (source != null && !this._sources.has(source)) {
+        this._sources.add(source);
+      }
+
+      if (name != null && !this._names.has(name)) {
+        this._names.add(name);
+      }
+
+      this._mappings.add({
+        generatedLine: generated.line,
+        generatedColumn: generated.column,
+        originalLine: original != null && original.line,
+        originalColumn: original != null && original.column,
+        source: source,
+        name: name
+      });
+    };
+
+  /**
+   * Set the source content for a source file.
+   */
+  SourceMapGenerator.prototype.setSourceContent =
+    function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+      var source = aSourceFile;
+      if (this._sourceRoot != null) {
+        source = util.relative(this._sourceRoot, source);
+      }
+
+      if (aSourceContent != null) {
+        // Add the source content to the _sourcesContents map.
+        // Create a new _sourcesContents map if the property is null.
+        if (!this._sourcesContents) {
+          this._sourcesContents = {};
+        }
+        this._sourcesContents[util.toSetString(source)] = aSourceContent;
+      } else if (this._sourcesContents) {
+        // Remove the source file from the _sourcesContents map.
+        // If the _sourcesContents map is empty, set the property to null.
+        delete this._sourcesContents[util.toSetString(source)];
+        if (Object.keys(this._sourcesContents).length === 0) {
+          this._sourcesContents = null;
+        }
+      }
+    };
+
+  /**
+   * Applies the mappings of a sub-source-map for a specific source file to the
+   * source map being generated. Each mapping to the supplied source file is
+   * rewritten using the supplied source map. Note: The resolution for the
+   * resulting mappings is the minimium of this map and the supplied map.
+   *
+   * @param aSourceMapConsumer The source map to be applied.
+   * @param aSourceFile Optional. The filename of the source file.
+   *        If omitted, SourceMapConsumer's file property will be used.
+   * @param aSourceMapPath Optional. The dirname of the path to the source map
+   *        to be applied. If relative, it is relative to the SourceMapConsumer.
+   *        This parameter is needed when the two source maps aren't in the same
+   *        directory, and the source map to be applied contains relative source
+   *        paths. If so, those relative source paths need to be rewritten
+   *        relative to the SourceMapGenerator.
+   */
+  SourceMapGenerator.prototype.applySourceMap =
+    function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+      var sourceFile = aSourceFile;
+      // If aSourceFile is omitted, we will use the file property of the SourceMap
+      if (aSourceFile == null) {
+        if (aSourceMapConsumer.file == null) {
+          throw new Error(
+            'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
+            'or the source map\'s "file" property. Both were omitted.'
+          );
+        }
+        sourceFile = aSourceMapConsumer.file;
+      }
+      var sourceRoot = this._sourceRoot;
+      // Make "sourceFile" relative if an absolute Url is passed.
+      if (sourceRoot != null) {
+        sourceFile = util.relative(sourceRoot, sourceFile);
+      }
+      // Applying the SourceMap can add and remove items from the sources and
+      // the names array.
+      var newSources = new ArraySet();
+      var newNames = new ArraySet();
+
+      // Find mappings for the "sourceFile"
+      this._mappings.unsortedForEach(function (mapping) {
+        if (mapping.source === sourceFile && mapping.originalLine != null) {
+          // Check if it can be mapped by the source map, then update the mapping.
+          var original = aSourceMapConsumer.originalPositionFor({
+            line: mapping.originalLine,
+            column: mapping.originalColumn
+          });
+          if (original.source != null) {
+            // Copy mapping
+            mapping.source = original.source;
+            if (aSourceMapPath != null) {
+              mapping.source = util.join(aSourceMapPath, mapping.source)
+            }
+            if (sourceRoot != null) {
+              mapping.source = util.relative(sourceRoot, mapping.source);
+            }
+            mapping.originalLine = original.line;
+            mapping.originalColumn = original.column;
+            if (original.name != null) {
+              mapping.name = original.name;
+            }
+          }
+        }
+
+        var source = mapping.source;
+        if (source != null && !newSources.has(source)) {
+          newSources.add(source);
+        }
+
+        var name = mapping.name;
+        if (name != null && !newNames.has(name)) {
+          newNames.add(name);
+        }
+
+      }, this);
+      this._sources = newSources;
+      this._names = newNames;
+
+      // Copy sourcesContents of applied map.
+      aSourceMapConsumer.sources.forEach(function (sourceFile) {
+        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+        if (content != null) {
+          if (aSourceMapPath != null) {
+            sourceFile = util.join(aSourceMapPath, sourceFile);
+          }
+          if (sourceRoot != null) {
+            sourceFile = util.relative(sourceRoot, sourceFile);
+          }
+          this.setSourceContent(sourceFile, content);
+        }
+      }, this);
+    };
+
+  /**
+   * A mapping can have one of the three levels of data:
+   *
+   *   1. Just the generated position.
+   *   2. The Generated position, original position, and original source.
+   *   3. Generated and original position, original source, as well as a name
+   *      token.
+   *
+   * To maintain consistency, we validate that any new mapping being added falls
+   * in to one of these categories.
+   */
+  SourceMapGenerator.prototype._validateMapping =
+    function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+                                                aName) {
+      if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+          && aGenerated.line > 0 && aGenerated.column >= 0
+          && !aOriginal && !aSource && !aName) {
+        // Case 1.
+        return;
+      }
+      else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+               && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+               && aGenerated.line > 0 && aGenerated.column >= 0
+               && aOriginal.line > 0 && aOriginal.column >= 0
+               && aSource) {
+        // Cases 2 and 3.
+        return;
+      }
+      else {
+        throw new Error('Invalid mapping: ' + JSON.stringify({
+          generated: aGenerated,
+          source: aSource,
+          original: aOriginal,
+          name: aName
+        }));
+      }
+    };
+
+  /**
+   * Serialize the accumulated mappings in to the stream of base 64 VLQs
+   * specified by the source map format.
+   */
+  SourceMapGenerator.prototype._serializeMappings =
+    function SourceMapGenerator_serializeMappings() {
+      var previousGeneratedColumn = 0;
+      var previousGeneratedLine = 1;
+      var previousOriginalColumn = 0;
+      var previousOriginalLine = 0;
+      var previousName = 0;
+      var previousSource = 0;
+      var result = '';
+      var mapping;
+
+      var mappings = this._mappings.toArray();
+
+      for (var i = 0, len = mappings.length; i < len; i++) {
+        mapping = mappings[i];
+
+        if (mapping.generatedLine !== previousGeneratedLine) {
+          previousGeneratedColumn = 0;
+          while (mapping.generatedLine !== previousGeneratedLine) {
+            result += ';';
+            previousGeneratedLine++;
+          }
+        }
+        else {
+          if (i > 0) {
+            if (!util.compareByGeneratedPositions(mapping, mappings[i - 1])) {
+              continue;
+            }
+            result += ',';
+          }
+        }
+
+        result += base64VLQ.encode(mapping.generatedColumn
+                                   - previousGeneratedColumn);
+        previousGeneratedColumn = mapping.generatedColumn;
+
+        if (mapping.source != null) {
+          result += base64VLQ.encode(this._sources.indexOf(mapping.source)
+                                     - previousSource);
+          previousSource = this._sources.indexOf(mapping.source);
+
+          // lines are stored 0-based in SourceMap spec version 3
+          result += base64VLQ.encode(mapping.originalLine - 1
+                                     - previousOriginalLine);
+          previousOriginalLine = mapping.originalLine - 1;
+
+          result += base64VLQ.encode(mapping.originalColumn
+                                     - previousOriginalColumn);
+          previousOriginalColumn = mapping.originalColumn;
+
+          if (mapping.name != null) {
+            result += base64VLQ.encode(this._names.indexOf(mapping.name)
+                                       - previousName);
+            previousName = this._names.indexOf(mapping.name);
+          }
+        }
+      }
+
+      return result;
+    };
+
+  SourceMapGenerator.prototype._generateSourcesContent =
+    function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+      return aSources.map(function (source) {
+        if (!this._sourcesContents) {
+          return null;
+        }
+        if (aSourceRoot != null) {
+          source = util.relative(aSourceRoot, source);
+        }
+        var key = util.toSetString(source);
+        return Object.prototype.hasOwnProperty.call(this._sourcesContents,
+                                                    key)
+          ? this._sourcesContents[key]
+          : null;
+      }, this);
+    };
+
+  /**
+   * Externalize the source map.
+   */
+  SourceMapGenerator.prototype.toJSON =
+    function SourceMapGenerator_toJSON() {
+      var map = {
+        version: this._version,
+        sources: this._sources.toArray(),
+        names: this._names.toArray(),
+        mappings: this._serializeMappings()
+      };
+      if (this._file != null) {
+        map.file = this._file;
+      }
+      if (this._sourceRoot != null) {
+        map.sourceRoot = this._sourceRoot;
+      }
+      if (this._sourcesContents) {
+        map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+      }
+
+      return map;
+    };
+
+  /**
+   * Render the source map being generated to a string.
+   */
+  SourceMapGenerator.prototype.toString =
+    function SourceMapGenerator_toString() {
+      return JSON.stringify(this);
+    };
+
+  exports.SourceMapGenerator = SourceMapGenerator;
+
+});
+
+},{"./array-set":327,"./base64-vlq":328,"./mapping-list":331,"./util":335,"amdefine":336}],334:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
+  var util = require('./util');
+
+  // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
+  // operating systems these days (capturing the result).
+  var REGEX_NEWLINE = /(\r?\n)/;
+
+  // Newline character code for charCodeAt() comparisons
+  var NEWLINE_CODE = 10;
+
+  // Private symbol for identifying `SourceNode`s when multiple versions of
+  // the source-map library are loaded. This MUST NOT CHANGE across
+  // versions!
+  var isSourceNode = "$$$isSourceNode$$$";
+
+  /**
+   * SourceNodes provide a way to abstract over interpolating/concatenating
+   * snippets of generated JavaScript source code while maintaining the line and
+   * column information associated with the original source code.
+   *
+   * @param aLine The original line number.
+   * @param aColumn The original column number.
+   * @param aSource The original source's filename.
+   * @param aChunks Optional. An array of strings which are snippets of
+   *        generated JS, or other SourceNodes.
+   * @param aName The original identifier.
+   */
+  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+    this.children = [];
+    this.sourceContents = {};
+    this.line = aLine == null ? null : aLine;
+    this.column = aColumn == null ? null : aColumn;
+    this.source = aSource == null ? null : aSource;
+    this.name = aName == null ? null : aName;
+    this[isSourceNode] = true;
+    if (aChunks != null) this.add(aChunks);
+  }
+
+  /**
+   * Creates a SourceNode from generated code and a SourceMapConsumer.
+   *
+   * @param aGeneratedCode The generated code
+   * @param aSourceMapConsumer The SourceMap for the generated code
+   * @param aRelativePath Optional. The path that relative sources in the
+   *        SourceMapConsumer should be relative to.
+   */
+  SourceNode.fromStringWithSourceMap =
+    function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+      // The SourceNode we want to fill with the generated code
+      // and the SourceMap
+      var node = new SourceNode();
+
+      // All even indices of this array are one line of the generated code,
+      // while all odd indices are the newlines between two adjacent lines
+      // (since `REGEX_NEWLINE` captures its match).
+      // Processed fragments are removed from this array, by calling `shiftNextLine`.
+      var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+      var shiftNextLine = function() {
+        var lineContents = remainingLines.shift();
+        // The last line of a file might not have a newline.
+        var newLine = remainingLines.shift() || "";
+        return lineContents + newLine;
+      };
+
+      // We need to remember the position of "remainingLines"
+      var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+      // The generate SourceNodes we need a code range.
+      // To extract it current and last mapping is used.
+      // Here we store the last mapping.
+      var lastMapping = null;
+
+      aSourceMapConsumer.eachMapping(function (mapping) {
+        if (lastMapping !== null) {
+          // We add the code from "lastMapping" to "mapping":
+          // First check if there is a new line in between.
+          if (lastGeneratedLine < mapping.generatedLine) {
+            var code = "";
+            // Associate first line with "lastMapping"
+            addMappingWithCode(lastMapping, shiftNextLine());
+            lastGeneratedLine++;
+            lastGeneratedColumn = 0;
+            // The remaining code is added without mapping
+          } else {
+            // There is no new line in between.
+            // Associate the code between "lastGeneratedColumn" and
+            // "mapping.generatedColumn" with "lastMapping"
+            var nextLine = remainingLines[0];
+            var code = nextLine.substr(0, mapping.generatedColumn -
+                                          lastGeneratedColumn);
+            remainingLines[0] = nextLine.substr(mapping.generatedColumn -
+                                                lastGeneratedColumn);
+            lastGeneratedColumn = mapping.generatedColumn;
+            addMappingWithCode(lastMapping, code);
+            // No more remaining code, continue
+            lastMapping = mapping;
+            return;
+          }
+        }
+        // We add the generated code until the first mapping
+        // to the SourceNode without any mapping.
+        // Each line is added as separate string.
+        while (lastGeneratedLine < mapping.generatedLine) {
+          node.add(shiftNextLine());
+          lastGeneratedLine++;
+        }
+        if (lastGeneratedColumn < mapping.generatedColumn) {
+          var nextLine = remainingLines[0];
+          node.add(nextLine.substr(0, mapping.generatedColumn));
+          remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+          lastGeneratedColumn = mapping.generatedColumn;
+        }
+        lastMapping = mapping;
+      }, this);
+      // We have processed all mappings.
+      if (remainingLines.length > 0) {
+        if (lastMapping) {
+          // Associate the remaining code in the current line with "lastMapping"
+          addMappingWithCode(lastMapping, shiftNextLine());
+        }
+        // and add the remaining lines without any mapping
+        node.add(remainingLines.join(""));
+      }
+
+      // Copy sourcesContent into SourceNode
+      aSourceMapConsumer.sources.forEach(function (sourceFile) {
+        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+        if (content != null) {
+          if (aRelativePath != null) {
+            sourceFile = util.join(aRelativePath, sourceFile);
+          }
+          node.setSourceContent(sourceFile, content);
+        }
+      });
+
+      return node;
+
+      function addMappingWithCode(mapping, code) {
+        if (mapping === null || mapping.source === undefined) {
+          node.add(code);
+        } else {
+          var source = aRelativePath
+            ? util.join(aRelativePath, mapping.source)
+            : mapping.source;
+          node.add(new SourceNode(mapping.originalLine,
+                                  mapping.originalColumn,
+                                  source,
+                                  code,
+                                  mapping.name));
+        }
+      }
+    };
+
+  /**
+   * Add a chunk of generated JS to this source node.
+   *
+   * @param aChunk A string snippet of generated JS code, another instance of
+   *        SourceNode, or an array where each member is one of those things.
+   */
+  SourceNode.prototype.add = function SourceNode_add(aChunk) {
+    if (Array.isArray(aChunk)) {
+      aChunk.forEach(function (chunk) {
+        this.add(chunk);
+      }, this);
+    }
+    else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      if (aChunk) {
+        this.children.push(aChunk);
+      }
+    }
+    else {
+      throw new TypeError(
+        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+      );
+    }
+    return this;
+  };
+
+  /**
+   * Add a chunk of generated JS to the beginning of this source node.
+   *
+   * @param aChunk A string snippet of generated JS code, another instance of
+   *        SourceNode, or an array where each member is one of those things.
+   */
+  SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+    if (Array.isArray(aChunk)) {
+      for (var i = aChunk.length-1; i >= 0; i--) {
+        this.prepend(aChunk[i]);
+      }
+    }
+    else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      this.children.unshift(aChunk);
+    }
+    else {
+      throw new TypeError(
+        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+      );
+    }
+    return this;
+  };
+
+  /**
+   * Walk over the tree of JS snippets in this node and its children. The
+   * walking function is called once for each snippet of JS and is passed that
+   * snippet and the its original associated source's line/column location.
+   *
+   * @param aFn The traversal function.
+   */
+  SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+    var chunk;
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      chunk = this.children[i];
+      if (chunk[isSourceNode]) {
+        chunk.walk(aFn);
+      }
+      else {
+        if (chunk !== '') {
+          aFn(chunk, { source: this.source,
+                       line: this.line,
+                       column: this.column,
+                       name: this.name });
+        }
+      }
+    }
+  };
+
+  /**
+   * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+   * each of `this.children`.
+   *
+   * @param aSep The separator.
+   */
+  SourceNode.prototype.join = function SourceNode_join(aSep) {
+    var newChildren;
+    var i;
+    var len = this.children.length;
+    if (len > 0) {
+      newChildren = [];
+      for (i = 0; i < len-1; i++) {
+        newChildren.push(this.children[i]);
+        newChildren.push(aSep);
+      }
+      newChildren.push(this.children[i]);
+      this.children = newChildren;
+    }
+    return this;
+  };
+
+  /**
+   * Call String.prototype.replace on the very right-most source snippet. Useful
+   * for trimming whitespace from the end of a source node, etc.
+   *
+   * @param aPattern The pattern to replace.
+   * @param aReplacement The thing to replace the pattern with.
+   */
+  SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+    var lastChild = this.children[this.children.length - 1];
+    if (lastChild[isSourceNode]) {
+      lastChild.replaceRight(aPattern, aReplacement);
+    }
+    else if (typeof lastChild === 'string') {
+      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+    }
+    else {
+      this.children.push(''.replace(aPattern, aReplacement));
+    }
+    return this;
+  };
+
+  /**
+   * Set the source content for a source file. This will be added to the SourceMapGenerator
+   * in the sourcesContent field.
+   *
+   * @param aSourceFile The filename of the source file
+   * @param aSourceContent The content of the source file
+   */
+  SourceNode.prototype.setSourceContent =
+    function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+      this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+    };
+
+  /**
+   * Walk over the tree of SourceNodes. The walking function is called for each
+   * source file content and is passed the filename and source content.
+   *
+   * @param aFn The traversal function.
+   */
+  SourceNode.prototype.walkSourceContents =
+    function SourceNode_walkSourceContents(aFn) {
+      for (var i = 0, len = this.children.length; i < len; i++) {
+        if (this.children[i][isSourceNode]) {
+          this.children[i].walkSourceContents(aFn);
+        }
+      }
+
+      var sources = Object.keys(this.sourceContents);
+      for (var i = 0, len = sources.length; i < len; i++) {
+        aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+      }
+    };
+
+  /**
+   * Return the string representation of this source node. Walks over the tree
+   * and concatenates all the various snippets together to one string.
+   */
+  SourceNode.prototype.toString = function SourceNode_toString() {
+    var str = "";
+    this.walk(function (chunk) {
+      str += chunk;
+    });
+    return str;
+  };
+
+  /**
+   * Returns the string representation of this source node along with a source
+   * map.
+   */
+  SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+    var generated = {
+      code: "",
+      line: 1,
+      column: 0
+    };
+    var map = new SourceMapGenerator(aArgs);
+    var sourceMappingActive = false;
+    var lastOriginalSource = null;
+    var lastOriginalLine = null;
+    var lastOriginalColumn = null;
+    var lastOriginalName = null;
+    this.walk(function (chunk, original) {
+      generated.code += chunk;
+      if (original.source !== null
+          && original.line !== null
+          && original.column !== null) {
+        if(lastOriginalSource !== original.source
+           || lastOriginalLine !== original.line
+           || lastOriginalColumn !== original.column
+           || lastOriginalName !== original.name) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+        lastOriginalSource = original.source;
+        lastOriginalLine = original.line;
+        lastOriginalColumn = original.column;
+        lastOriginalName = original.name;
+        sourceMappingActive = true;
+      } else if (sourceMappingActive) {
+        map.addMapping({
+          generated: {
+            line: generated.line,
+            column: generated.column
+          }
+        });
+        lastOriginalSource = null;
+        sourceMappingActive = false;
+      }
+      for (var idx = 0, length = chunk.length; idx < length; idx++) {
+        if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+          generated.line++;
+          generated.column = 0;
+          // Mappings end at eol
+          if (idx + 1 === length) {
+            lastOriginalSource = null;
+            sourceMappingActive = false;
+          } else if (sourceMappingActive) {
+            map.addMapping({
+              source: original.source,
+              original: {
+                line: original.line,
+                column: original.column
+              },
+              generated: {
+                line: generated.line,
+                column: generated.column
+              },
+              name: original.name
+            });
+          }
+        } else {
+          generated.column++;
+        }
+      }
+    });
+    this.walkSourceContents(function (sourceFile, sourceContent) {
+      map.setSourceContent(sourceFile, sourceContent);
+    });
+
+    return { code: generated.code, map: map };
+  };
+
+  exports.SourceNode = SourceNode;
+
+});
+
+},{"./source-map-generator":333,"./util":335,"amdefine":336}],335:[function(require,module,exports){
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+if (typeof define !== 'function') {
+    var define = require('amdefine')(module, require);
+}
+define(function (require, exports, module) {
+
+  /**
+   * This is a helper function for getting values from parameter/options
+   * objects.
+   *
+   * @param args The object we are extracting values from
+   * @param name The name of the property we are getting.
+   * @param defaultValue An optional value to return if the property is missing
+   * from the object. If this is not specified and the property is missing, an
+   * error will be thrown.
+   */
+  function getArg(aArgs, aName, aDefaultValue) {
+    if (aName in aArgs) {
+      return aArgs[aName];
+    } else if (arguments.length === 3) {
+      return aDefaultValue;
+    } else {
+      throw new Error('"' + aName + '" is a required argument.');
+    }
+  }
+  exports.getArg = getArg;
+
+  var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
+  var dataUrlRegexp = /^data:.+\,.+$/;
+
+  function urlParse(aUrl) {
+    var match = aUrl.match(urlRegexp);
+    if (!match) {
+      return null;
+    }
+    return {
+      scheme: match[1],
+      auth: match[2],
+      host: match[3],
+      port: match[4],
+      path: match[5]
+    };
+  }
+  exports.urlParse = urlParse;
+
+  function urlGenerate(aParsedUrl) {
+    var url = '';
+    if (aParsedUrl.scheme) {
+      url += aParsedUrl.scheme + ':';
+    }
+    url += '//';
+    if (aParsedUrl.auth) {
+      url += aParsedUrl.auth + '@';
+    }
+    if (aParsedUrl.host) {
+      url += aParsedUrl.host;
+    }
+    if (aParsedUrl.port) {
+      url += ":" + aParsedUrl.port
+    }
+    if (aParsedUrl.path) {
+      url += aParsedUrl.path;
+    }
+    return url;
+  }
+  exports.urlGenerate = urlGenerate;
+
+  /**
+   * Normalizes a path, or the path portion of a URL:
+   *
+   * - Replaces consequtive slashes with one slash.
+   * - Removes unnecessary '.' parts.
+   * - Removes unnecessary '<dir>/..' parts.
+   *
+   * Based on code in the Node.js 'path' core module.
+   *
+   * @param aPath The path or url to normalize.
+   */
+  function normalize(aPath) {
+    var path = aPath;
+    var url = urlParse(aPath);
+    if (url) {
+      if (!url.path) {
+        return aPath;
+      }
+      path = url.path;
+    }
+    var isAbsolute = (path.charAt(0) === '/');
+
+    var parts = path.split(/\/+/);
+    for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+      part = parts[i];
+      if (part === '.') {
+        parts.splice(i, 1);
+      } else if (part === '..') {
+        up++;
+      } else if (up > 0) {
+        if (part === '') {
+          // The first part is blank if the path is absolute. Trying to go
+          // above the root is a no-op. Therefore we can remove all '..' parts
+          // directly after the root.
+          parts.splice(i + 1, up);
+          up = 0;
+        } else {
+          parts.splice(i, 2);
+          up--;
+        }
+      }
+    }
+    path = parts.join('/');
+
+    if (path === '') {
+      path = isAbsolute ? '/' : '.';
+    }
+
+    if (url) {
+      url.path = path;
+      return urlGenerate(url);
+    }
+    return path;
+  }
+  exports.normalize = normalize;
+
+  /**
+   * Joins two paths/URLs.
+   *
+   * @param aRoot The root path or URL.
+   * @param aPath The path or URL to be joined with the root.
+   *
+   * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+   *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+   *   first.
+   * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+   *   is updated with the result and aRoot is returned. Otherwise the result
+   *   is returned.
+   *   - If aPath is absolute, the result is aPath.
+   *   - Otherwise the two paths are joined with a slash.
+   * - Joining for example 'http://' and 'www.example.com' is also supported.
+   */
+  function join(aRoot, aPath) {
+    if (aRoot === "") {
+      aRoot = ".";
+    }
+    if (aPath === "") {
+      aPath = ".";
+    }
+    var aPathUrl = urlParse(aPath);
+    var aRootUrl = urlParse(aRoot);
+    if (aRootUrl) {
+      aRoot = aRootUrl.path || '/';
+    }
+
+    // `join(foo, '//www.example.org')`
+    if (aPathUrl && !aPathUrl.scheme) {
+      if (aRootUrl) {
+        aPathUrl.scheme = aRootUrl.scheme;
+      }
+      return urlGenerate(aPathUrl);
+    }
+
+    if (aPathUrl || aPath.match(dataUrlRegexp)) {
+      return aPath;
+    }
+
+    // `join('http://', 'www.example.com')`
+    if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+      aRootUrl.host = aPath;
+      return urlGenerate(aRootUrl);
+    }
+
+    var joined = aPath.charAt(0) === '/'
+      ? aPath
+      : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+    if (aRootUrl) {
+      aRootUrl.path = joined;
+      return urlGenerate(aRootUrl);
+    }
+    return joined;
+  }
+  exports.join = join;
+
+  /**
+   * Make a path relative to a URL or another path.
+   *
+   * @param aRoot The root path or URL.
+   * @param aPath The path or URL to be made relative to aRoot.
+   */
+  function relative(aRoot, aPath) {
+    if (aRoot === "") {
+      aRoot = ".";
+    }
+
+    aRoot = aRoot.replace(/\/$/, '');
+
+    // XXX: It is possible to remove this block, and the tests still pass!
+    var url = urlParse(aRoot);
+    if (aPath.charAt(0) == "/" && url && url.path == "/") {
+      return aPath.slice(1);
+    }
+
+    return aPath.indexOf(aRoot + '/') === 0
+      ? aPath.substr(aRoot.length + 1)
+      : aPath;
+  }
+  exports.relative = relative;
+
+  /**
+   * Because behavior goes wacky when you set `__proto__` on objects, we
+   * have to prefix all the strings in our set with an arbitrary character.
+   *
+   * See https://github.com/mozilla/source-map/pull/31 and
+   * https://github.com/mozilla/source-map/issues/30
+   *
+   * @param String aStr
+   */
+  function toSetString(aStr) {
+    return '$' + aStr;
+  }
+  exports.toSetString = toSetString;
+
+  function fromSetString(aStr) {
+    return aStr.substr(1);
+  }
+  exports.fromSetString = fromSetString;
+
+  function strcmp(aStr1, aStr2) {
+    var s1 = aStr1 || "";
+    var s2 = aStr2 || "";
+    return (s1 > s2) - (s1 < s2);
+  }
+
+  /**
+   * Comparator between two mappings where the original positions are compared.
+   *
+   * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+   * mappings with the same original source/line/column, but different generated
+   * line and column the same. Useful when searching for a mapping with a
+   * stubbed out mapping.
+   */
+  function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+    var cmp;
+
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp) {
+      return cmp;
+    }
+
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp) {
+      return cmp;
+    }
+
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp || onlyCompareOriginal) {
+      return cmp;
+    }
+
+    cmp = strcmp(mappingA.name, mappingB.name);
+    if (cmp) {
+      return cmp;
+    }
+
+    cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp) {
+      return cmp;
+    }
+
+    return mappingA.generatedColumn - mappingB.generatedColumn;
+  };
+  exports.compareByOriginalPositions = compareByOriginalPositions;
+
+  /**
+   * Comparator between two mappings where the generated positions are
+   * compared.
+   *
+   * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+   * mappings with the same generated line and column, but different
+   * source/name/original line and column the same. Useful when searching for a
+   * mapping with a stubbed out mapping.
+   */
+  function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
+    var cmp;
+
+    cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp) {
+      return cmp;
+    }
+
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp || onlyCompareGenerated) {
+      return cmp;
+    }
+
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp) {
+      return cmp;
+    }
+
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp) {
+      return cmp;
+    }
+
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp) {
+      return cmp;
+    }
+
+    return strcmp(mappingA.name, mappingB.name);
+  };
+  exports.compareByGeneratedPositions = compareByGeneratedPositions;
+
+});
+
+},{"amdefine":336}],336:[function(require,module,exports){
+(function (process,__filename){
+/** vim: et:ts=4:sw=4:sts=4
+ * @license amdefine 0.1.0 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/amdefine for details
+ */
+
+/*jslint node: true */
+/*global module, process */
+'use strict';
+
+/**
+ * Creates a define for node.
+ * @param {Object} module the "module" object that is defined by Node for the
+ * current module.
+ * @param {Function} [requireFn]. Node's require function for the current module.
+ * It only needs to be passed in Node versions before 0.5, when module.require
+ * did not exist.
+ * @returns {Function} a define function that is usable for the current node
+ * module.
+ */
+function amdefine(module, requireFn) {
+    'use strict';
+    var defineCache = {},
+        loaderCache = {},
+        alreadyCalled = false,
+        path = require('path'),
+        makeRequire, stringRequire;
+
+    /**
+     * Trims the . and .. from an array of path segments.
+     * It will keep a leading path segment if a .. will become
+     * the first path segment, to help with module name lookups,
+     * which act like paths, but can be remapped. But the end result,
+     * all paths that use this function should look normalized.
+     * NOTE: this method MODIFIES the input array.
+     * @param {Array} ary the array of path segments.
+     */
+    function trimDots(ary) {
+        var i, part;
+        for (i = 0; ary[i]; i+= 1) {
+            part = ary[i];
+            if (part === '.') {
+                ary.splice(i, 1);
+                i -= 1;
+            } else if (part === '..') {
+                if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
+                    //End of the line. Keep at least one non-dot
+                    //path segment at the front so it can be mapped
+                    //correctly to disk. Otherwise, there is likely
+                    //no path mapping for a path starting with '..'.
+                    //This can still fail, but catches the most reasonable
+                    //uses of ..
+                    break;
+                } else if (i > 0) {
+                    ary.splice(i - 1, 2);
+                    i -= 2;
+                }
+            }
+        }
+    }
+
+    function normalize(name, baseName) {
+        var baseParts;
+
+        //Adjust any relative paths.
+        if (name && name.charAt(0) === '.') {
+            //If have a base name, try to normalize against it,
+            //otherwise, assume it is a top-level require that will
+            //be relative to baseUrl in the end.
+            if (baseName) {
+                baseParts = baseName.split('/');
+                baseParts = baseParts.slice(0, baseParts.length - 1);
+                baseParts = baseParts.concat(name.split('/'));
+                trimDots(baseParts);
+                name = baseParts.join('/');
+            }
+        }
+
+        return name;
+    }
+
+    /**
+     * Create the normalize() function passed to a loader plugin's
+     * normalize method.
+     */
+    function makeNormalize(relName) {
+        return function (name) {
+            return normalize(name, relName);
+        };
+    }
+
+    function makeLoad(id) {
+        function load(value) {
+            loaderCache[id] = value;
+        }
+
+        load.fromText = function (id, text) {
+            //This one is difficult because the text can/probably uses
+            //define, and any relative paths and requires should be relative
+            //to that id was it would be found on disk. But this would require
+            //bootstrapping a module/require fairly deeply from node core.
+            //Not sure how best to go about that yet.
+            throw new Error('amdefine does not implement load.fromText');
+        };
+
+        return load;
+    }
+
+    makeRequire = function (systemRequire, exports, module, relId) {
+        function amdRequire(deps, callback) {
+            if (typeof deps === 'string') {
+                //Synchronous, single module require('')
+                return stringRequire(systemRequire, exports, module, deps, relId);
+            } else {
+                //Array of dependencies with a callback.
+
+                //Convert the dependencies to modules.
+                deps = deps.map(function (depName) {
+                    return stringRequire(systemRequire, exports, module, depName, relId);
+                });
+
+                //Wait for next tick to call back the require call.
+                process.nextTick(function () {
+                    callback.apply(null, deps);
+                });
+            }
+        }
+
+        amdRequire.toUrl = function (filePath) {
+            if (filePath.indexOf('.') === 0) {
+                return normalize(filePath, path.dirname(module.filename));
+            } else {
+                return filePath;
+            }
+        };
+
+        return amdRequire;
+    };
+
+    //Favor explicit value, passed in if the module wants to support Node 0.4.
+    requireFn = requireFn || function req() {
+        return module.require.apply(module, arguments);
+    };
+
+    function runFactory(id, deps, factory) {
+        var r, e, m, result;
+
+        if (id) {
+            e = loaderCache[id] = {};
+            m = {
+                id: id,
+                uri: __filename,
+                exports: e
+            };
+            r = makeRequire(requireFn, e, m, id);
+        } else {
+            //Only support one define call per file
+            if (alreadyCalled) {
+                throw new Error('amdefine with no module ID cannot be called more than once per file.');
+            }
+            alreadyCalled = true;
+
+            //Use the real variables from node
+            //Use module.exports for exports, since
+            //the exports in here is amdefine exports.
+            e = module.exports;
+            m = module;
+            r = makeRequire(requireFn, e, m, module.id);
+        }
+
+        //If there are dependencies, they are strings, so need
+        //to convert them to dependency values.
+        if (deps) {
+            deps = deps.map(function (depName) {
+                return r(depName);
+            });
+        }
+
+        //Call the factory with the right dependencies.
+        if (typeof factory === 'function') {
+            result = factory.apply(m.exports, deps);
+        } else {
+            result = factory;
+        }
+
+        if (result !== undefined) {
+            m.exports = result;
+            if (id) {
+                loaderCache[id] = m.exports;
+            }
+        }
+    }
+
+    stringRequire = function (systemRequire, exports, module, id, relId) {
+        //Split the ID by a ! so that
+        var index = id.indexOf('!'),
+            originalId = id,
+            prefix, plugin;
+
+        if (index === -1) {
+            id = normalize(id, relId);
+
+            //Straight module lookup. If it is one of the special dependencies,
+            //deal with it, otherwise, delegate to node.
+            if (id === 'require') {
+                return makeRequire(systemRequire, exports, module, relId);
+            } else if (id === 'exports') {
+                return exports;
+            } else if (id === 'module') {
+                return module;
+            } else if (loaderCache.hasOwnProperty(id)) {
+                return loaderCache[id];
+            } else if (defineCache[id]) {
+                runFactory.apply(null, defineCache[id]);
+                return loaderCache[id];
+            } else {
+                if(systemRequire) {
+                    return systemRequire(originalId);
+                } else {
+                    throw new Error('No module with ID: ' + id);
+                }
+            }
+        } else {
+            //There is a plugin in play.
+            prefix = id.substring(0, index);
+            id = id.substring(index + 1, id.length);
+
+            plugin = stringRequire(systemRequire, exports, module, prefix, relId);
+
+            if (plugin.normalize) {
+                id = plugin.normalize(id, makeNormalize(relId));
+            } else {
+                //Normalize the ID normally.
+                id = normalize(id, relId);
+            }
+
+            if (loaderCache[id]) {
+                return loaderCache[id];
+            } else {
+                plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {});
+
+                return loaderCache[id];
+            }
+        }
+    };
+
+    //Create a define function specific to the module asking for amdefine.
+    function define(id, deps, factory) {
+        if (Array.isArray(id)) {
+            factory = deps;
+            deps = id;
+            id = undefined;
+        } else if (typeof id !== 'string') {
+            factory = id;
+            id = deps = undefined;
+        }
+
+        if (deps && !Array.isArray(deps)) {
+            factory = deps;
+            deps = undefined;
+        }
+
+        if (!deps) {
+            deps = ['require', 'exports', 'module'];
+        }
+
+        //Set up properties for this module. If an ID, then use
+        //internal cache. If no ID, then use the external variables
+        //for this node module.
+        if (id) {
+            //Put the module in deep freeze until there is a
+            //require call for it.
+            defineCache[id] = [id, deps, factory];
+        } else {
+            runFactory(id, deps, factory);
+        }
+    }
+
+    //define.require, which has access to all the values in the
+    //cache. Useful for AMD modules that all have IDs in the file,
+    //but need to finally export a value to node based on one of those
+    //IDs.
+    define.require = function (id) {
+        if (loaderCache[id]) {
+            return loaderCache[id];
+        }
+
+        if (defineCache[id]) {
+            runFactory.apply(null, defineCache[id]);
+            return loaderCache[id];
+        }
+    };
+
+    define.amd = {};
+
+    return define;
+}
+
+module.exports = amdefine;
+
+}).call(this,require('_process'),"/node_modules/source-map/node_modules/amdefine/amdefine.js")
+},{"_process":147,"path":146}],337:[function(require,module,exports){
+'use strict';
+module.exports = function (str) {
+	return str.replace(/[\s\uFEFF\xA0]+$/g, '');
+};
+
+},{}],338:[function(require,module,exports){
+module.exports={
+  "name": "babel",
+  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
+  "version": "4.5.0",
+  "author": "Sebastian McKenzie <sebmck@gmail.com>",
+  "homepage": "https://babeljs.io/",
+  "repository": "babel/babel",
+  "preferGlobal": true,
+  "main": "lib/babel/api/node.js",
+  "browser": {
+    "./lib/babel/api/register/node.js": "./lib/babel/api/register/browser.js"
+  },
+  "bin": {
+    "6to5": "./bin/deprecated/6to5",
+    "6to5-node": "./bin/deprecated/6to5-node",
+    "6to5-runtime": "./bin/deprecated/6to5-runtime",
+    "babel": "./bin/babel/index.js",
+    "babel-node": "./bin/babel-node",
+    "babel-external-helpers": "./bin/babel-external-helpers"
+  },
+  "keywords": [
+    "harmony",
+    "classes",
+    "modules",
+    "let",
+    "const",
+    "var",
+    "es6",
+    "transpile",
+    "transpiler",
+    "6to5",
+    "babel"
+  ],
+  "scripts": {
+    "bench": "make bench",
+    "test": "make test"
+  },
+  "dependencies": {
+    "acorn-babel": "0.11.1-34",
+    "ast-types": "~0.6.1",
+    "chalk": "^1.0.0",
+    "chokidar": "^0.12.6",
+    "commander": "^2.6.0",
+    "core-js": "^0.6.1",
+    "debug": "^2.1.1",
+    "detect-indent": "^3.0.0",
+    "estraverse": "^1.9.1",
+    "esutils": "^1.1.6",
+    "fs-readdir-recursive": "^0.1.0",
+    "globals": "^6.2.0",
+    "is-integer": "^1.0.4",
+    "js-tokens": "0.4.1",
+    "leven": "^1.0.1",
+    "line-numbers": "0.2.0",
+    "lodash": "^3.2.0",
+    "output-file-sync": "^1.1.0",
+    "path-is-absolute": "^1.0.0",
+    "private": "^0.1.6",
+    "regenerator-babel": "0.8.13-1",
+    "regexpu": "^1.1.1",
+    "repeating": "^1.1.2",
+    "shebang-regex": "^1.0.0",
+    "slash": "^1.0.0",
+    "source-map": "^0.1.43",
+    "source-map-support": "^0.2.9",
+    "source-map-to-comment": "^1.0.0",
+    "trim-right": "^1.0.0"
+  },
+  "devDependencies": {
+    "browserify": "^8.1.3",
+    "chai": "^2.0.0",
+    "esvalid": "^1.1.0",
+    "istanbul": "^0.3.5",
+    "jscs": "^1.11.3",
+    "jshint": "^2.6.0",
+    "jshint-stylish": "^1.0.0",
+    "matcha": "^0.6.0",
+    "mocha": "^2.1.0",
+    "rimraf": "^2.2.8",
+    "uglify-js": "^2.4.16"
+  }
+}
+
+},{}],339:[function(require,module,exports){
+module.exports={"abstract-expression-call":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"PROPERTY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"referenceGet","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"call","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"abstract-expression-delete":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"PROPERTY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"referenceDelete","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"abstract-expression-get":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"PROPERTY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"referenceGet","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"abstract-expression-set":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"PROPERTY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"referenceSet","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"apply-constructor":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"args","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instance","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"create","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"result","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"apply","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instance","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"args","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"result","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!=","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"result","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"object","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"||","right":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"result","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"function","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"result","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instance","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"array-comprehension-container":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"ArrayExpression","start":null,"end":null,"loc":null,"range":null,"elements":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"array-from":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"from","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"array-push":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"push","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"STATEMENT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"async-to-generator":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"fn","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"gen","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"fn","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"apply","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"ThisExpression","start":null,"end":null,"loc":null,"range":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"NewExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Promise","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"resolve","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"reject","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"callNext","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"step","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"bind","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"next","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"callThrow","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"step","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"bind","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"throw","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"FunctionDeclaration","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"step","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arg","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"TryStatement","start":null,"end":null,"loc":null,"range":null,"block":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"info","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"gen","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arg","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"info","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"handler":{"type":"CatchClause","start":null,"end":null,"loc":null,"range":null,"param":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"error","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"guard":null,"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"reject","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"error","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"guardedHandlers":[],"finalizer":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"info","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"done","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"resolve","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Promise","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"resolve","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"then","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"callNext","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"callThrow","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"callNext","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"bind":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Function","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"bind","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"call":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"call","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"CONTEXT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"class-call-check":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instance","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"!","prefix":true,"argument":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instance","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"instanceof","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ThrowStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"NewExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"TypeError","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"Cannot call a class as a function","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"class-super-constructor-call-loose":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"SUPER_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!=","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"SUPER_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"apply","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"ThisExpression","start":null,"end":null,"loc":null,"range":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"class-super-constructor-call":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"SUPER_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!=","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"SUPER_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"apply","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"ThisExpression","start":null,"end":null,"loc":null,"range":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"corejs-is-iterator":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"CORE_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"$for","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"isIterable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"corejs-iterator":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"CORE_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"$for","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getIterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"default-parameter":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VARIABLE_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARGUMENTS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARGUMENT_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"DEFAULT_VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARGUMENTS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARGUMENT_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"let","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"defaults":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defaults","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"keys","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getOwnPropertyNames","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defaults","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":0,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"<","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"keys","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"update":{"type":"UpdateExpression","start":null,"end":null,"loc":null,"range":null,"operator":"++","prefix":false,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"keys","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getOwnPropertyDescriptor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defaults","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"configurable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defineProperty","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"define-property":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defineProperty","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"enumerable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"configurable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"writable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"exports-assign":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"exports-default-assign":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"module","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VALUE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"exports-module-declaration-loose":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"__esModule","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"exports-module-declaration":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defineProperty","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"__esModule","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"extends":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"assign","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"||","right":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"target","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":1,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"<","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"update":{"type":"UpdateExpression","start":null,"end":null,"loc":null,"range":null,"operator":"++","prefix":false,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"source","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ForInStatement","start":null,"end":null,"loc":null,"range":null,"left":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"source","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"hasOwnProperty","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"call","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"source","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"target","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"source","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"key","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"target","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"for-of-loose":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"IS_ARRAY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"isArray","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"INDEX","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":0,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"IS_ARRAY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"iterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":null,"update":null,"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"IS_ARRAY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"INDEX","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":">=","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BreakStatement","start":null,"end":null,"loc":null,"range":null,"label":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"UpdateExpression","start":null,"end":null,"loc":null,"range":null,"operator":"++","prefix":false,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"INDEX","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"INDEX","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LOOP_OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"next","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"INDEX","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"done","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BreakStatement","start":null,"end":null,"loc":null,"range":null,"label":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"INDEX","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"for-of":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ITERATOR_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"OBJECT","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"iterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"STEP_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"!","prefix":true,"argument":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"STEP_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ITERATOR_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"next","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"done","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"update":null,"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"get":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"get","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"property","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"receiver","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getOwnPropertyDescriptor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"property","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"parent","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getPrototypeOf","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"parent","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"get","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"parent","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"property","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"receiver","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"value","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"operator":"in","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"writable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getter","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"get","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getter","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getter","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"call","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"receiver","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"has-own":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"hasOwnProperty","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"inherits":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"subClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"function","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ThrowStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"NewExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"TypeError","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"Super expression must either be null or a function, not ","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"operator":"+","right":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"subClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"create","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"subClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"enumerable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":false,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"writable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"configurable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"subClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"__proto__","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"superClass","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"interop-require-wildcard":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"__esModule","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"default","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"interop-require":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"__esModule","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"default","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"let-scoping-return":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"RETURN","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"object","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"RETURN","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"v","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"named-function":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"FunctionDeclaration","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"GET_OUTER_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"object-destructuring-empty":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ThrowStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"NewExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"TypeError","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"Cannot destructure undefined","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"object-without-properties":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"keys","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"target","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ForInStatement","start":null,"end":null,"loc":null,"range":null,"left":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"keys","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"indexOf","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":">=","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":0,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ContinueStatement","start":null,"end":null,"loc":null,"range":null,"label":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"!","prefix":true,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"hasOwnProperty","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"call","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ContinueStatement","start":null,"end":null,"loc":null,"range":null,"label":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"target","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"target","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property-method-assignment-wrapper-generator":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"WRAPPER_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"generator":true,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"YieldExpression","start":null,"end":null,"loc":null,"range":null,"delegate":true,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"apply","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"ThisExpression","start":null,"end":null,"loc":null,"range":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"WRAPPER_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"toString","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"toString","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"WRAPPER_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property-method-assignment-wrapper":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"WRAPPER_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"apply","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"ThisExpression","start":null,"end":null,"loc":null,"range":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arguments","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"WRAPPER_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"toString","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"toString","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"WRAPPER_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"prototype-identifier":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"CLASS_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"prototype-properties":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"child","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"staticProps","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instanceProps","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"staticProps","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defineProperties","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"child","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"staticProps","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instanceProps","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defineProperties","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"child","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"instanceProps","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"require-assign-key":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"VARIABLE_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"require","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"MODULE_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"require":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"require","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"MODULE_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"rest":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LEN","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARGUMENTS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARRAY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARRAY_LEN","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"START","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"<","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"LEN","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"update":{"type":"UpdateExpression","start":null,"end":null,"loc":null,"range":null,"operator":"++","prefix":false,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARRAY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARRAY_KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ARGUMENTS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"KEY","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"self-contained-helpers-head":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"helpers","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"default","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"__esModule","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"self-global":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"global","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"undefined","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"self","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"global","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"set":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"set","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"property","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"receiver","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getOwnPropertyDescriptor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"property","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"parent","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"getPrototypeOf","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"parent","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":null,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"set","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"parent","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"property","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"receiver","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"value","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"operator":"in","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"writable","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"setter","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"desc","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"set","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"setter","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!==","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undefined","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"setter","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"call","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"receiver","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"slice":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"prototype","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"slice","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"sliced-to-array":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"isArray","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"iterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"in","right":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"ArrayExpression","start":null,"end":null,"loc":null,"range":null,"elements":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_iterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"iterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_step","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"!","prefix":true,"argument":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_step","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_iterator","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"next","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"done","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"update":null,"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"push","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_step","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BreakStatement","start":null,"end":null,"loc":null,"range":null,"label":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"_arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ThrowStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"NewExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"TypeError","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"Invalid attempt to destructure non-iterable instance","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"system":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"System","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"register","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"MODULE_NAME","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"MODULE_DEPENDENCIES","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"EXPORT_IDENTIFIER","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"setters","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"SETTERS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"execute","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"EXECUTE","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"tagged-template-literal-loose":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"strings","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"raw","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"strings","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"raw","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"raw","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"strings","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"tagged-template-literal":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"strings","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"raw","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"freeze","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"defineProperties","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"strings","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"raw","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[{"type":"Property","start":null,"end":null,"loc":null,"range":null,"method":false,"shorthand":false,"computed":false,"key":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"value","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"value":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Object","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"freeze","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"raw","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"kind":"init","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"tail-call-body":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"AGAIN_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"LabeledStatement","start":null,"end":null,"loc":null,"range":null,"body":{"type":"WhileStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"AGAIN_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"BLOCK","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"label":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"FUNCTION_ID","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"temporal-assert-defined":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"val","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"name","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undef","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"val","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"undef","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ThrowStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"NewExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"ReferenceError","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"name","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"+","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":" is not defined - temporal dead zone","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":true,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"temporal-undefined":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"ObjectExpression","start":null,"end":null,"loc":null,"range":null,"properties":[],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test-exports":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"exports","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"undefined","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test-module":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"module","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"!==","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"undefined","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"to-array":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"isArray","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"alternate":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"from","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"to-consumable-array":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"isArray","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ForStatement","start":null,"end":null,"loc":null,"range":null,"init":{"type":"VariableDeclaration","start":null,"end":null,"loc":null,"range":null,"declarations":[{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":0,"raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"VariableDeclarator","start":null,"end":null,"loc":null,"range":null,"id":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr2","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"init":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"kind":"var","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"test":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"<","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"length","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"update":{"type":"UpdateExpression","start":null,"end":null,"loc":null,"range":null,"operator":"++","prefix":false,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"body":{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"AssignmentExpression","start":null,"end":null,"loc":null,"range":null,"operator":"=","left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr2","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"i","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":true,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr2","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Array","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"from","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"arr","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"typeof":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ReturnStatement","start":null,"end":null,"loc":null,"range":null,"argument":{"type":"ConditionalExpression","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"constructor","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"Symbol","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"symbol","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"alternate":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"obj","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"umd-runner-body":{"type":"Program","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"FunctionExpression","start":null,"end":null,"loc":null,"range":null,"id":null,"generator":false,"expression":false,"params":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"factory","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"body":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"LogicalExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"BinaryExpression","start":null,"end":null,"loc":null,"range":null,"left":{"type":"UnaryExpression","start":null,"end":null,"loc":null,"range":null,"operator":"typeof","prefix":true,"argument":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"define","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"===","right":{"type":"Literal","start":null,"end":null,"loc":null,"range":null,"value":"function","raw":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"operator":"&&","right":{"type":"MemberExpression","start":null,"end":null,"loc":null,"range":null,"object":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"define","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"property":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"amd","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"computed":false,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"define","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"AMD_ARGUMENTS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"factory","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":{"type":"IfStatement","start":null,"end":null,"loc":null,"range":null,"test":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"COMMON_TEST","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"consequent":{"type":"BlockStatement","start":null,"end":null,"loc":null,"range":null,"body":[{"type":"ExpressionStatement","start":null,"end":null,"loc":null,"range":null,"expression":{"type":"CallExpression","start":null,"end":null,"loc":null,"range":null,"callee":{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"factory","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"arguments":[{"type":"Identifier","start":null,"end":null,"loc":null,"range":null,"name":"COMMON_ARGUMENTS","_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"alternate":null,"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_scopeInfo":null,"_declarations":null,"extendedRange":null,"tokens":null,"raw":null},"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}],"_declarations":null,"extendedRange":null,"_scopeInfo":null,"tokens":null,"raw":null}}
+},{}]},{},[1])(1)
+});
\ No newline at end of file
diff --git a/test/fixtures/uglify.js b/test/fixtures/uglify.js
new file mode 100644
index 0000000..ca48b66
--- /dev/null
+++ b/test/fixtures/uglify.js
@@ -0,0 +1,2613 @@
+// https://developer.mozilla.org/en/JavaScript/Reference/global_objects/array/foreach
+
+if (!Array.prototype.forEach)
+{
+  Array.prototype.forEach = function(fun /*, thisp */)
+  {
+    "use strict";
+
+    if (this === void 0 || this === null)
+      throw new TypeError();
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun !== "function")
+      throw new TypeError();
+
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++)
+    {
+      if (i in t)
+        fun.call(thisp, t[i], i, t);
+    }
+  };
+}
+
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+// Production steps of ECMA-262, Edition 5, 15.4.4.19
+// Reference: http://es5.github.com/#x15.4.4.19
+if (!Array.prototype.map) {
+  Array.prototype.map = function(callback, thisArg) {
+
+    var T, A, k;
+
+    if (this == null) {
+      throw new TypeError(" this is null or not defined");
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if ({}.toString.call(callback) != "[object Function]") {
+      throw new TypeError(callback + " is not a function");
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (thisArg) {
+      T = thisArg;
+    }
+
+    // 6. Let A be a new array created as if by the expression new Array(len) where Array is
+    // the standard built-in constructor with that name and len is the value of len.
+    A = new Array(len);
+
+    // 7. Let k be 0
+    k = 0;
+
+    // 8. Repeat, while k < len
+    while(k < len) {
+
+      var kValue, mappedValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
+        kValue = O[ k ];
+
+        // ii. Let mappedValue be the result of calling the Call internal method of callback
+        // with T as the this value and argument list containing kValue, k, and O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Call the DefineOwnProperty internal method of A with arguments
+        // Pk, Property Descriptor {Value: mappedValue, Writable: true, Enumerable: true, Configurable: true},
+        // and false.
+
+        // In browsers that support Object.defineProperty, use the following:
+        // Object.defineProperty(A, Pk, { value: mappedValue, writable: true, enumerable: true, configurable: true });
+
+        // For best browser support, use the following:
+        A[ k ] = mappedValue;
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+
+    // 9. return A
+    return A;
+  };
+}
+
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/Reduce
+
+if (!Array.prototype.reduce)
+{
+  Array.prototype.reduce = function(fun /*, initialValue */)
+  {
+    "use strict";
+
+    if (this === void 0 || this === null)
+      throw new TypeError();
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun !== "function")
+      throw new TypeError();
+
+    // no value to return if no initial value and an empty array
+    if (len == 0 && arguments.length == 1)
+      throw new TypeError();
+
+    var k = 0;
+    var accumulator;
+    if (arguments.length >= 2)
+    {
+      accumulator = arguments[1];
+    }
+    else
+    {
+      do
+      {
+        if (k in t)
+        {
+          accumulator = t[k++];
+          break;
+        }
+
+        // if array contains no values, no initial value to return
+        if (++k >= len)
+          throw new TypeError();
+      }
+      while (true);
+    }
+
+    while (k < len)
+    {
+      if (k in t)
+        accumulator = fun.call(undefined, accumulator, t[k], k, t);
+      k++;
+    }
+
+    return accumulator;
+  };
+}
+
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
+if (!Array.prototype.indexOf) {
+    Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
+        "use strict";
+        if (this === void 0 || this === null) {
+            throw new TypeError();
+        }
+        var t = Object(this);
+        var len = t.length >>> 0;
+        if (len === 0) {
+            return -1;
+        }
+        var n = 0;
+        if (arguments.length > 0) {
+            n = Number(arguments[1]);
+            if (n !== n) { // shortcut for verifying if it's NaN
+                n = 0;
+            } else if (n !== 0 && n !== Infinity && n !== -Infinity) {
+                n = (n > 0 || -1) * Math.floor(Math.abs(n));
+            }
+        }
+        if (n >= len) {
+            return -1;
+        }
+        var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+        for (; k < len; k++) {
+            if (k in t && t[k] === searchElement) {
+                return k;
+            }
+        }
+        return -1;
+    }
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Object/keys
+if (!Object.keys) {
+  Object.keys = (function () {
+    var hasOwnProperty = Object.prototype.hasOwnProperty,
+        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
+        dontEnums = [
+          'toString',
+          'toLocaleString',
+          'valueOf',
+          'hasOwnProperty',
+          'isPrototypeOf',
+          'propertyIsEnumerable',
+          'constructor'
+        ],
+        dontEnumsLength = dontEnums.length;
+
+    return function (obj) {
+      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');
+
+      var result = [];
+
+      for (var prop in obj) {
+        if (hasOwnProperty.call(obj, prop)) result.push(prop);
+      }
+
+      if (hasDontEnumBug) {
+        for (var i=0; i < dontEnumsLength; i++) {
+          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
+        }
+      }
+      return result;
+    }
+  })()
+};
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Object/create
+if (!Object.create) {
+    Object.create = function (o) {
+        if (arguments.length > 1) {
+            throw new Error('Object.create implementation only accepts the first parameter.');
+        }
+        function F() {}
+        F.prototype = o;
+        return new F();
+    };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Array/filter
+if (!Array.prototype.filter)
+{
+  Array.prototype.filter = function(fun /*, thisp*/)
+  {
+    "use strict";
+
+    if (this == null)
+      throw new TypeError();
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    var res = [];
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++)
+    {
+      if (i in t)
+      {
+        var val = t[i]; // in case fun mutates this
+        if (fun.call(thisp, val, i, t))
+          res.push(val);
+      }
+    }
+
+    return res;
+  };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Function/bind
+if (!Function.prototype.bind) {
+  Function.prototype.bind = function (oThis) {
+    if (typeof this !== "function") {
+      // closest thing possible to the ECMAScript 5 internal IsCallable function
+      throw new TypeError("Function.prototype.bind - 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 && oThis
+                                 ? this
+                                 : oThis,
+                               aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/Array/isArray
+if(!Array.isArray) {
+  Array.isArray = function (vArg) {
+    return Object.prototype.toString.call(vArg) === "[object Array]";
+  };
+}
+
+// https://developer.mozilla.org/en/docs/JavaScript/Reference/Global_Objects/String/trim
+if(!String.prototype.trim) {
+  String.prototype.trim = function () {
+    return this.replace(/^\s+|\s+$/g,'');
+  };
+}
+
+
+function definePropertyWorks() {
+  try {
+    Object.defineProperty({}, "property", {});
+    return "property" in object;
+  } catch (exception) {
+    return false;
+  }
+}
+
+if (!definePropertyWorks()) {
+  Object.defineProperty = function defineProperty(object) {
+    // fail silently
+    return object;
+  }
+}
+
+/*!
+ * Cross-Browser Split 1.1.1
+ * Copyright 2007-2012 Steven Levithan <stevenlevithan.com>
+ * Available under the MIT License
+ * ECMAScript compliant, uniform cross-browser split method
+ */
+
+/**
+ * Splits a string into an array of strings using a regex or string separator. Matches of the
+ * separator are not included in the result array. However, if `separator` is a regex that contains
+ * capturing groups, backreferences are spliced into the result each time `separator` is matched.
+ * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
+ * cross-browser.
+ * @param {String} str String to split.
+ * @param {RegExp|String} separator Regex or string to use for separating the string.
+ * @param {Number} [limit] Maximum number of items to include in the result array.
+ * @returns {Array} Array of substrings.
+ * @example
+ *
+ * // Basic use
+ * split('a b c d', ' ');
+ * // -> ['a', 'b', 'c', 'd']
+ *
+ * // With limit
+ * split('a b c d', ' ', 2);
+ * // -> ['a', 'b']
+ *
+ * // Backreferences in result array
+ * split('..word1 word2..', /([a-z]+)(\d+)/i);
+ * // -> ['..', 'word', '1', ' ', 'word', '2', '..']
+ */
+var split;
+
+// Avoid running twice; that would break the `nativeSplit` reference
+split = split || function (undef) {
+
+    var nativeSplit = String.prototype.split,
+        compliantExecNpcg = /()??/.exec("")[1] === undef, // NPCG: nonparticipating capturing group
+        self;
+
+    self = function (str, separator, limit) {
+        // If `separator` is not a regex, use `nativeSplit`
+        if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
+            return nativeSplit.call(str, separator, limit);
+        }
+        var output = [],
+            flags = (separator.ignoreCase ? "i" : "") +
+                    (separator.multiline  ? "m" : "") +
+                    (separator.extended   ? "x" : "") + // Proposed for ES6
+                    (separator.sticky     ? "y" : ""), // Firefox 3+
+            lastLastIndex = 0,
+            // Make `global` and avoid `lastIndex` issues by working with a copy
+            separator = new RegExp(separator.source, flags + "g"),
+            separator2, match, lastIndex, lastLength;
+        str += ""; // Type-convert
+        if (!compliantExecNpcg) {
+            // Doesn't need flags gy, but they don't hurt
+            separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags);
+        }
+        /* Values for `limit`, per the spec:
+         * If undefined: 4294967295 // Math.pow(2, 32) - 1
+         * If 0, Infinity, or NaN: 0
+         * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
+         * If negative number: 4294967296 - Math.floor(Math.abs(limit))
+         * If other: Type-convert, then use the above rules
+         */
+        limit = limit === undef ?
+            -1 >>> 0 : // Math.pow(2, 32) - 1
+            limit >>> 0; // ToUint32(limit)
+        while (match = separator.exec(str)) {
+            // `separator.lastIndex` is not reliable cross-browser
+            lastIndex = match.index + match[0].length;
+            if (lastIndex > lastLastIndex) {
+                output.push(str.slice(lastLastIndex, match.index));
+                // Fix browsers whose `exec` methods don't consistently return `undefined` for
+                // nonparticipating capturing groups
+                if (!compliantExecNpcg && match.length > 1) {
+                    match[0].replace(separator2, function () {
+                        for (var i = 1; i < arguments.length - 2; i++) {
+                            if (arguments[i] === undef) {
+                                match[i] = undef;
+                            }
+                        }
+                    });
+                }
+                if (match.length > 1 && match.index < str.length) {
+                    Array.prototype.push.apply(output, match.slice(1));
+                }
+                lastLength = match[0].length;
+                lastLastIndex = lastIndex;
+                if (output.length >= limit) {
+                    break;
+                }
+            }
+            if (separator.lastIndex === match.index) {
+                separator.lastIndex++; // Avoid an infinite loop
+            }
+        }
+        if (lastLastIndex === str.length) {
+            if (lastLength || !separator.test("")) {
+                output.push("");
+            }
+        } else {
+            output.push(str.slice(lastLastIndex));
+        }
+        return output.length > limit ? output.slice(0, limit) : output;
+    };
+
+    if ("\n".split(/\n/).length == 0) {
+        String.prototype.split = function (separator, limit) {
+            return self(this, separator, limit);
+        };
+    }
+
+    return self;
+
+}();
+
+window = this;/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * Define a module along with a payload.
+ * @param {string} moduleName Name for the payload
+ * @param {ignored} deps Ignored. For compatibility with CommonJS AMD Spec
+ * @param {function} payload Function with (require, exports, module) params
+ */
+function define(moduleName, deps, payload) {
+  if (typeof moduleName != "string") {
+    throw new TypeError('Expected string, got: ' + moduleName);
+  }
+
+  if (arguments.length == 2) {
+    payload = deps;
+  }
+
+  if (moduleName in define.modules) {
+    throw new Error("Module already defined: " + moduleName);
+  }
+  define.modules[moduleName] = payload;
+};
+
+/**
+ * The global store of un-instantiated modules
+ */
+define.modules = {};
+
+
+/**
+ * We invoke require() in the context of a Domain so we can have multiple
+ * sets of modules running separate from each other.
+ * This contrasts with JSMs which are singletons, Domains allows us to
+ * optionally load a CommonJS module twice with separate data each time.
+ * Perhaps you want 2 command lines with a different set of commands in each,
+ * for example.
+ */
+function Domain() {
+  this.modules = {};
+  this._currentModule = null;
+}
+
+(function () {
+
+  /**
+   * Lookup module names and resolve them by calling the definition function if
+   * needed.
+   * There are 2 ways to call this, either with an array of dependencies and a
+   * callback to call when the dependencies are found (which can happen
+   * asynchronously in an in-page context) or with a single string an no callback
+   * where the dependency is resolved synchronously and returned.
+   * The API is designed to be compatible with the CommonJS AMD spec and
+   * RequireJS.
+   * @param {string[]|string} deps A name, or names for the payload
+   * @param {function|undefined} callback Function to call when the dependencies
+   * are resolved
+   * @return {undefined|object} The module required or undefined for
+   * array/callback method
+   */
+  Domain.prototype.require = function(deps, callback) {
+    if (Array.isArray(deps)) {
+      var params = deps.map(function(dep) {
+        return this.lookup(dep);
+      }, this);
+      if (callback) {
+        callback.apply(null, params);
+      }
+      return undefined;
+    }
+    else {
+      return this.lookup(deps);
+    }
+  };
+
+  function normalize(path) {
+    var bits = path.split('/');
+    var i = 1;
+    while (i < bits.length) {
+      if (bits[i] === '..') {
+        bits.splice(i-1, 1);
+      } else if (bits[i] === '.') {
+        bits.splice(i, 1);
+      } else {
+        i++;
+      }
+    }
+    return bits.join('/');
+  }
+
+  function join(a, b) {
+    a = a.trim();
+    b = b.trim();
+    if (/^\//.test(b)) {
+      return b;
+    } else {
+      return a.replace(/\/*$/, '/') + b;
+    }
+  }
+
+  function dirname(path) {
+    var bits = path.split('/');
+    bits.pop();
+    return bits.join('/');
+  }
+
+  /**
+   * Lookup module names and resolve them by calling the definition function if
+   * needed.
+   * @param {string} moduleName A name for the payload to lookup
+   * @return {object} The module specified by aModuleName or null if not found.
+   */
+  Domain.prototype.lookup = function(moduleName) {
+    if (/^\./.test(moduleName)) {
+      moduleName = normalize(join(dirname(this._currentModule), moduleName));
+    }
+
+    if (moduleName in this.modules) {
+      var module = this.modules[moduleName];
+      return module;
+    }
+
+    if (!(moduleName in define.modules)) {
+      throw new Error("Module not defined: " + moduleName);
+    }
+
+    var module = define.modules[moduleName];
+
+    if (typeof module == "function") {
+      var exports = {};
+      var previousModule = this._currentModule;
+      this._currentModule = moduleName;
+      module(this.require.bind(this), exports, { id: moduleName, uri: "" });
+      this._currentModule = previousModule;
+      module = exports;
+    }
+
+    // cache the resulting module object for next time
+    this.modules[moduleName] = module;
+
+    return module;
+  };
+
+}());
+
+define.Domain = Domain;
+define.globalDomain = new Domain();
+var require = define.globalDomain.require.bind(define.globalDomain);
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/source-map-generator', ['require', 'exports', 'module' ,  'source-map/base64-vlq', 'source-map/util', 'source-map/array-set'], function(require, exports, module) {
+
+  var base64VLQ = require('./base64-vlq');
+  var util = require('./util');
+  var ArraySet = require('./array-set').ArraySet;
+
+  /**
+   * An instance of the SourceMapGenerator represents a source map which is
+   * being built incrementally. To create a new one, you must pass an object
+   * with the following properties:
+   *
+   *   - file: The filename of the generated source.
+   *   - sourceRoot: An optional root for all URLs in this source map.
+   */
+  function SourceMapGenerator(aArgs) {
+    this._file = util.getArg(aArgs, 'file');
+    this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+    this._sources = new ArraySet();
+    this._names = new ArraySet();
+    this._mappings = [];
+    this._sourcesContents = null;
+  }
+
+  SourceMapGenerator.prototype._version = 3;
+
+  /**
+   * Creates a new SourceMapGenerator based on a SourceMapConsumer
+   *
+   * @param aSourceMapConsumer The SourceMap.
+   */
+  SourceMapGenerator.fromSourceMap =
+    function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
+      var sourceRoot = aSourceMapConsumer.sourceRoot;
+      var generator = new SourceMapGenerator({
+        file: aSourceMapConsumer.file,
+        sourceRoot: sourceRoot
+      });
+      aSourceMapConsumer.eachMapping(function (mapping) {
+        var newMapping = {
+          generated: {
+            line: mapping.generatedLine,
+            column: mapping.generatedColumn
+          }
+        };
+
+        if (mapping.source) {
+          newMapping.source = mapping.source;
+          if (sourceRoot) {
+            newMapping.source = util.relative(sourceRoot, newMapping.source);
+          }
+
+          newMapping.original = {
+            line: mapping.originalLine,
+            column: mapping.originalColumn
+          };
+
+          if (mapping.name) {
+            newMapping.name = mapping.name;
+          }
+        }
+
+        generator.addMapping(newMapping);
+      });
+      aSourceMapConsumer.sources.forEach(function (sourceFile) {
+        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+        if (content) {
+          generator.setSourceContent(sourceFile, content);
+        }
+      });
+      return generator;
+    };
+
+  /**
+   * Add a single mapping from original source line and column to the generated
+   * source's line and column for this source map being created. The mapping
+   * object should have the following properties:
+   *
+   *   - generated: An object with the generated line and column positions.
+   *   - original: An object with the original line and column positions.
+   *   - source: The original source file (relative to the sourceRoot).
+   *   - name: An optional original token name for this mapping.
+   */
+  SourceMapGenerator.prototype.addMapping =
+    function SourceMapGenerator_addMapping(aArgs) {
+      var generated = util.getArg(aArgs, 'generated');
+      var original = util.getArg(aArgs, 'original', null);
+      var source = util.getArg(aArgs, 'source', null);
+      var name = util.getArg(aArgs, 'name', null);
+
+      this._validateMapping(generated, original, source, name);
+
+      if (source && !this._sources.has(source)) {
+        this._sources.add(source);
+      }
+
+      if (name && !this._names.has(name)) {
+        this._names.add(name);
+      }
+
+      this._mappings.push({
+        generated: generated,
+        original: original,
+        source: source,
+        name: name
+      });
+    };
+
+  /**
+   * Set the source content for a source file.
+   */
+  SourceMapGenerator.prototype.setSourceContent =
+    function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+      var source = aSourceFile;
+      if (this._sourceRoot) {
+        source = util.relative(this._sourceRoot, source);
+      }
+
+      if (aSourceContent !== null) {
+        // Add the source content to the _sourcesContents map.
+        // Create a new _sourcesContents map if the property is null.
+        if (!this._sourcesContents) {
+          this._sourcesContents = {};
+        }
+        this._sourcesContents[util.toSetString(source)] = aSourceContent;
+      } else {
+        // Remove the source file from the _sourcesContents map.
+        // If the _sourcesContents map is empty, set the property to null.
+        delete this._sourcesContents[util.toSetString(source)];
+        if (Object.keys(this._sourcesContents).length === 0) {
+          this._sourcesContents = null;
+        }
+      }
+    };
+
+  /**
+   * Applies the mappings of a sub-source-map for a specific source file to the
+   * source map being generated. Each mapping to the supplied source file is
+   * rewritten using the supplied source map. Note: The resolution for the
+   * resulting mappings is the minimium of this map and the supplied map.
+   *
+   * @param aSourceMapConsumer The source map to be applied.
+   * @param aSourceFile Optional. The filename of the source file.
+   *        If omitted, SourceMapConsumer's file property will be used.
+   */
+  SourceMapGenerator.prototype.applySourceMap =
+    function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile) {
+      // If aSourceFile is omitted, we will use the file property of the SourceMap
+      if (!aSourceFile) {
+        aSourceFile = aSourceMapConsumer.file;
+      }
+      var sourceRoot = this._sourceRoot;
+      // Make "aSourceFile" relative if an absolute Url is passed.
+      if (sourceRoot) {
+        aSourceFile = util.relative(sourceRoot, aSourceFile);
+      }
+      // Applying the SourceMap can add and remove items from the sources and
+      // the names array.
+      var newSources = new ArraySet();
+      var newNames = new ArraySet();
+
+      // Find mappings for the "aSourceFile"
+      this._mappings.forEach(function (mapping) {
+        if (mapping.source === aSourceFile && mapping.original) {
+          // Check if it can be mapped by the source map, then update the mapping.
+          var original = aSourceMapConsumer.originalPositionFor({
+            line: mapping.original.line,
+            column: mapping.original.column
+          });
+          if (original.source !== null) {
+            // Copy mapping
+            if (sourceRoot) {
+              mapping.source = util.relative(sourceRoot, original.source);
+            } else {
+              mapping.source = original.source;
+            }
+            mapping.original.line = original.line;
+            mapping.original.column = original.column;
+            if (original.name !== null && mapping.name !== null) {
+              // Only use the identifier name if it's an identifier
+              // in both SourceMaps
+              mapping.name = original.name;
+            }
+          }
+        }
+
+        var source = mapping.source;
+        if (source && !newSources.has(source)) {
+          newSources.add(source);
+        }
+
+        var name = mapping.name;
+        if (name && !newNames.has(name)) {
+          newNames.add(name);
+        }
+
+      }, this);
+      this._sources = newSources;
+      this._names = newNames;
+
+      // Copy sourcesContents of applied map.
+      aSourceMapConsumer.sources.forEach(function (sourceFile) {
+        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+        if (content) {
+          if (sourceRoot) {
+            sourceFile = util.relative(sourceRoot, sourceFile);
+          }
+          this.setSourceContent(sourceFile, content);
+        }
+      }, this);
+    };
+
+  /**
+   * A mapping can have one of the three levels of data:
+   *
+   *   1. Just the generated position.
+   *   2. The Generated position, original position, and original source.
+   *   3. Generated and original position, original source, as well as a name
+   *      token.
+   *
+   * To maintain consistency, we validate that any new mapping being added falls
+   * in to one of these categories.
+   */
+  SourceMapGenerator.prototype._validateMapping =
+    function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+                                                aName) {
+      if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+          && aGenerated.line > 0 && aGenerated.column >= 0
+          && !aOriginal && !aSource && !aName) {
+        // Case 1.
+        return;
+      }
+      else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+               && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+               && aGenerated.line > 0 && aGenerated.column >= 0
+               && aOriginal.line > 0 && aOriginal.column >= 0
+               && aSource) {
+        // Cases 2 and 3.
+        return;
+      }
+      else {
+        throw new Error('Invalid mapping.');
+      }
+    };
+
+  function cmpLocation(loc1, loc2) {
+    var cmp = (loc1 && loc1.line) - (loc2 && loc2.line);
+    return cmp ? cmp : (loc1 && loc1.column) - (loc2 && loc2.column);
+  }
+
+  function strcmp(str1, str2) {
+    str1 = str1 || '';
+    str2 = str2 || '';
+    return (str1 > str2) - (str1 < str2);
+  }
+
+  function cmpMapping(mappingA, mappingB) {
+    return cmpLocation(mappingA.generated, mappingB.generated) ||
+      cmpLocation(mappingA.original, mappingB.original) ||
+      strcmp(mappingA.source, mappingB.source) ||
+      strcmp(mappingA.name, mappingB.name);
+  }
+
+  /**
+   * Serialize the accumulated mappings in to the stream of base 64 VLQs
+   * specified by the source map format.
+   */
+  SourceMapGenerator.prototype._serializeMappings =
+    function SourceMapGenerator_serializeMappings() {
+      var previousGeneratedColumn = 0;
+      var previousGeneratedLine = 1;
+      var previousOriginalColumn = 0;
+      var previousOriginalLine = 0;
+      var previousName = 0;
+      var previousSource = 0;
+      var result = '';
+      var mapping;
+
+      // The mappings must be guaranteed to be in sorted order before we start
+      // serializing them or else the generated line numbers (which are defined
+      // via the ';' separators) will be all messed up. Note: it might be more
+      // performant to maintain the sorting as we insert them, rather than as we
+      // serialize them, but the big O is the same either way.
+      this._mappings.sort(cmpMapping);
+
+      for (var i = 0, len = this._mappings.length; i < len; i++) {
+        mapping = this._mappings[i];
+
+        if (mapping.generated.line !== previousGeneratedLine) {
+          previousGeneratedColumn = 0;
+          while (mapping.generated.line !== previousGeneratedLine) {
+            result += ';';
+            previousGeneratedLine++;
+          }
+        }
+        else {
+          if (i > 0) {
+            if (!cmpMapping(mapping, this._mappings[i - 1])) {
+              continue;
+            }
+            result += ',';
+          }
+        }
+
+        result += base64VLQ.encode(mapping.generated.column
+                                   - previousGeneratedColumn);
+        previousGeneratedColumn = mapping.generated.column;
+
+        if (mapping.source && mapping.original) {
+          result += base64VLQ.encode(this._sources.indexOf(mapping.source)
+                                     - previousSource);
+          previousSource = this._sources.indexOf(mapping.source);
+
+          // lines are stored 0-based in SourceMap spec version 3
+          result += base64VLQ.encode(mapping.original.line - 1
+                                     - previousOriginalLine);
+          previousOriginalLine = mapping.original.line - 1;
+
+          result += base64VLQ.encode(mapping.original.column
+                                     - previousOriginalColumn);
+          previousOriginalColumn = mapping.original.column;
+
+          if (mapping.name) {
+            result += base64VLQ.encode(this._names.indexOf(mapping.name)
+                                       - previousName);
+            previousName = this._names.indexOf(mapping.name);
+          }
+        }
+      }
+
+      return result;
+    };
+
+  /**
+   * Externalize the source map.
+   */
+  SourceMapGenerator.prototype.toJSON =
+    function SourceMapGenerator_toJSON() {
+      var map = {
+        version: this._version,
+        file: this._file,
+        sources: this._sources.toArray(),
+        names: this._names.toArray(),
+        mappings: this._serializeMappings()
+      };
+      if (this._sourceRoot) {
+        map.sourceRoot = this._sourceRoot;
+      }
+      if (this._sourcesContents) {
+        map.sourcesContent = map.sources.map(function (source) {
+          if (map.sourceRoot) {
+            source = util.relative(map.sourceRoot, source);
+          }
+          return Object.prototype.hasOwnProperty.call(
+            this._sourcesContents, util.toSetString(source))
+            ? this._sourcesContents[util.toSetString(source)]
+            : null;
+        }, this);
+      }
+      return map;
+    };
+
+  /**
+   * Render the source map being generated to a string.
+   */
+  SourceMapGenerator.prototype.toString =
+    function SourceMapGenerator_toString() {
+      return JSON.stringify(this);
+    };
+
+  exports.SourceMapGenerator = SourceMapGenerator;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *  * Neither the name of Google Inc. nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+define('source-map/base64-vlq', ['require', 'exports', 'module' ,  'source-map/base64'], function(require, exports, module) {
+
+  var base64 = require('./base64');
+
+  // A single base 64 digit can contain 6 bits of data. For the base 64 variable
+  // length quantities we use in the source map spec, the first bit is the sign,
+  // the next four bits are the actual value, and the 6th bit is the
+  // continuation bit. The continuation bit tells us whether there are more
+  // digits in this value following this digit.
+  //
+  //   Continuation
+  //   |    Sign
+  //   |    |
+  //   V    V
+  //   101011
+
+  var VLQ_BASE_SHIFT = 5;
+
+  // binary: 100000
+  var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+  // binary: 011111
+  var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+  // binary: 100000
+  var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+  /**
+   * Converts from a two-complement value to a value where the sign bit is
+   * is placed in the least significant bit.  For example, as decimals:
+   *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+   *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+   */
+  function toVLQSigned(aValue) {
+    return aValue < 0
+      ? ((-aValue) << 1) + 1
+      : (aValue << 1) + 0;
+  }
+
+  /**
+   * Converts to a two-complement value from a value where the sign bit is
+   * is placed in the least significant bit.  For example, as decimals:
+   *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+   *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+   */
+  function fromVLQSigned(aValue) {
+    var isNegative = (aValue & 1) === 1;
+    var shifted = aValue >> 1;
+    return isNegative
+      ? -shifted
+      : shifted;
+  }
+
+  /**
+   * Returns the base 64 VLQ encoded value.
+   */
+  exports.encode = function base64VLQ_encode(aValue) {
+    var encoded = "";
+    var digit;
+
+    var vlq = toVLQSigned(aValue);
+
+    do {
+      digit = vlq & VLQ_BASE_MASK;
+      vlq >>>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        // There are still more digits in this value, so we must make sure the
+        // continuation bit is marked.
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64.encode(digit);
+    } while (vlq > 0);
+
+    return encoded;
+  };
+
+  /**
+   * Decodes the next base 64 VLQ value from the given string and returns the
+   * value and the rest of the string.
+   */
+  exports.decode = function base64VLQ_decode(aStr) {
+    var i = 0;
+    var strLen = aStr.length;
+    var result = 0;
+    var shift = 0;
+    var continuation, digit;
+
+    do {
+      if (i >= strLen) {
+        throw new Error("Expected more digits in base 64 VLQ value.");
+      }
+      digit = base64.decode(aStr.charAt(i++));
+      continuation = !!(digit & VLQ_CONTINUATION_BIT);
+      digit &= VLQ_BASE_MASK;
+      result = result + (digit << shift);
+      shift += VLQ_BASE_SHIFT;
+    } while (continuation);
+
+    return {
+      value: fromVLQSigned(result),
+      rest: aStr.slice(i)
+    };
+  };
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/base64', ['require', 'exports', 'module' , ], function(require, exports, module) {
+
+  var charToIntMap = {};
+  var intToCharMap = {};
+
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+    .split('')
+    .forEach(function (ch, index) {
+      charToIntMap[ch] = index;
+      intToCharMap[index] = ch;
+    });
+
+  /**
+   * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+   */
+  exports.encode = function base64_encode(aNumber) {
+    if (aNumber in intToCharMap) {
+      return intToCharMap[aNumber];
+    }
+    throw new TypeError("Must be between 0 and 63: " + aNumber);
+  };
+
+  /**
+   * Decode a single base 64 digit to an integer.
+   */
+  exports.decode = function base64_decode(aChar) {
+    if (aChar in charToIntMap) {
+      return charToIntMap[aChar];
+    }
+    throw new TypeError("Not a valid base 64 digit: " + aChar);
+  };
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/util', ['require', 'exports', 'module' , ], function(require, exports, module) {
+
+  /**
+   * This is a helper function for getting values from parameter/options
+   * objects.
+   *
+   * @param args The object we are extracting values from
+   * @param name The name of the property we are getting.
+   * @param defaultValue An optional value to return if the property is missing
+   * from the object. If this is not specified and the property is missing, an
+   * error will be thrown.
+   */
+  function getArg(aArgs, aName, aDefaultValue) {
+    if (aName in aArgs) {
+      return aArgs[aName];
+    } else if (arguments.length === 3) {
+      return aDefaultValue;
+    } else {
+      throw new Error('"' + aName + '" is a required argument.');
+    }
+  }
+  exports.getArg = getArg;
+
+  var urlRegexp = /([\w+\-.]+):\/\/((\w+:\w+)@)?([\w.]+)?(:(\d+))?(\S+)?/;
+
+  function urlParse(aUrl) {
+    var match = aUrl.match(urlRegexp);
+    if (!match) {
+      return null;
+    }
+    return {
+      scheme: match[1],
+      auth: match[3],
+      host: match[4],
+      port: match[6],
+      path: match[7]
+    };
+  }
+  exports.urlParse = urlParse;
+
+  function urlGenerate(aParsedUrl) {
+    var url = aParsedUrl.scheme + "://";
+    if (aParsedUrl.auth) {
+      url += aParsedUrl.auth + "@"
+    }
+    if (aParsedUrl.host) {
+      url += aParsedUrl.host;
+    }
+    if (aParsedUrl.port) {
+      url += ":" + aParsedUrl.port
+    }
+    if (aParsedUrl.path) {
+      url += aParsedUrl.path;
+    }
+    return url;
+  }
+  exports.urlGenerate = urlGenerate;
+
+  function join(aRoot, aPath) {
+    var url;
+
+    if (aPath.match(urlRegexp)) {
+      return aPath;
+    }
+
+    if (aPath.charAt(0) === '/' && (url = urlParse(aRoot))) {
+      url.path = aPath;
+      return urlGenerate(url);
+    }
+
+    return aRoot.replace(/\/$/, '') + '/' + aPath;
+  }
+  exports.join = join;
+
+  /**
+   * Because behavior goes wacky when you set `__proto__` on objects, we
+   * have to prefix all the strings in our set with an arbitrary character.
+   *
+   * See https://github.com/mozilla/source-map/pull/31 and
+   * https://github.com/mozilla/source-map/issues/30
+   *
+   * @param String aStr
+   */
+  function toSetString(aStr) {
+    return '$' + aStr;
+  }
+  exports.toSetString = toSetString;
+
+  function fromSetString(aStr) {
+    return aStr.substr(1);
+  }
+  exports.fromSetString = fromSetString;
+
+  function relative(aRoot, aPath) {
+    aRoot = aRoot.replace(/\/$/, '');
+
+    var url = urlParse(aRoot);
+    if (aPath.charAt(0) == "/" && url && url.path == "/") {
+      return aPath.slice(1);
+    }
+
+    return aPath.indexOf(aRoot + '/') === 0
+      ? aPath.substr(aRoot.length + 1)
+      : aPath;
+  }
+  exports.relative = relative;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/array-set', ['require', 'exports', 'module' ,  'source-map/util'], function(require, exports, module) {
+
+  var util = require('./util');
+
+  /**
+   * A data structure which is a combination of an array and a set. Adding a new
+   * member is O(1), testing for membership is O(1), and finding the index of an
+   * element is O(1). Removing elements from the set is not supported. Only
+   * strings are supported for membership.
+   */
+  function ArraySet() {
+    this._array = [];
+    this._set = {};
+  }
+
+  /**
+   * Static method for creating ArraySet instances from an existing array.
+   */
+  ArraySet.fromArray = function ArraySet_fromArray(aArray) {
+    var set = new ArraySet();
+    for (var i = 0, len = aArray.length; i < len; i++) {
+      set.add(aArray[i]);
+    }
+    return set;
+  };
+
+  /**
+   * Add the given string to this set.
+   *
+   * @param String aStr
+   */
+  ArraySet.prototype.add = function ArraySet_add(aStr) {
+    if (this.has(aStr)) {
+      // Already a member; nothing to do.
+      return;
+    }
+    var idx = this._array.length;
+    this._array.push(aStr);
+    this._set[util.toSetString(aStr)] = idx;
+  };
+
+  /**
+   * Is the given string a member of this set?
+   *
+   * @param String aStr
+   */
+  ArraySet.prototype.has = function ArraySet_has(aStr) {
+    return Object.prototype.hasOwnProperty.call(this._set,
+                                                util.toSetString(aStr));
+  };
+
+  /**
+   * What is the index of the given string in the array?
+   *
+   * @param String aStr
+   */
+  ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+    if (this.has(aStr)) {
+      return this._set[util.toSetString(aStr)];
+    }
+    throw new Error('"' + aStr + '" is not in the set.');
+  };
+
+  /**
+   * What is the element at the given index?
+   *
+   * @param Number aIdx
+   */
+  ArraySet.prototype.at = function ArraySet_at(aIdx) {
+    if (aIdx >= 0 && aIdx < this._array.length) {
+      return this._array[aIdx];
+    }
+    throw new Error('No element indexed by ' + aIdx);
+  };
+
+  /**
+   * Returns the array representation of this set (which has the proper indices
+   * indicated by indexOf). Note that this is a copy of the internal array used
+   * for storing the members so that no one can mess with internal state.
+   */
+  ArraySet.prototype.toArray = function ArraySet_toArray() {
+    return this._array.slice();
+  };
+
+  exports.ArraySet = ArraySet;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/source-map-consumer', ['require', 'exports', 'module' ,  'source-map/util', 'source-map/binary-search', 'source-map/array-set', 'source-map/base64-vlq'], function(require, exports, module) {
+
+  var util = require('./util');
+  var binarySearch = require('./binary-search');
+  var ArraySet = require('./array-set').ArraySet;
+  var base64VLQ = require('./base64-vlq');
+
+  /**
+   * A SourceMapConsumer instance represents a parsed source map which we can
+   * query for information about the original file positions by giving it a file
+   * position in the generated source.
+   *
+   * The only parameter is the raw source map (either as a JSON string, or
+   * already parsed to an object). According to the spec, source maps have the
+   * following attributes:
+   *
+   *   - version: Which version of the source map spec this map is following.
+   *   - sources: An array of URLs to the original source files.
+   *   - names: An array of identifiers which can be referrenced by individual mappings.
+   *   - sourceRoot: Optional. The URL root from which all sources are relative.
+   *   - sourcesContent: Optional. An array of contents of the original source files.
+   *   - mappings: A string of base64 VLQs which contain the actual mappings.
+   *   - file: The generated file this source map is associated with.
+   *
+   * Here is an example source map, taken from the source map spec[0]:
+   *
+   *     {
+   *       version : 3,
+   *       file: "out.js",
+   *       sourceRoot : "",
+   *       sources: ["foo.js", "bar.js"],
+   *       names: ["src", "maps", "are", "fun"],
+   *       mappings: "AA,AB;;ABCDE;"
+   *     }
+   *
+   * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+   */
+  function SourceMapConsumer(aSourceMap) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === 'string') {
+      sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+    }
+
+    var version = util.getArg(sourceMap, 'version');
+    var sources = util.getArg(sourceMap, 'sources');
+    var names = util.getArg(sourceMap, 'names');
+    var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+    var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+    var mappings = util.getArg(sourceMap, 'mappings');
+    var file = util.getArg(sourceMap, 'file');
+
+    if (version !== this._version) {
+      throw new Error('Unsupported version: ' + version);
+    }
+
+    this._names = ArraySet.fromArray(names);
+    this._sources = ArraySet.fromArray(sources);
+    this.sourceRoot = sourceRoot;
+    this.sourcesContent = sourcesContent;
+    this.file = file;
+
+    // `this._generatedMappings` and `this._originalMappings` hold the parsed
+    // mapping coordinates from the source map's "mappings" attribute. Each
+    // object in the array is of the form
+    //
+    //     {
+    //       generatedLine: The line number in the generated code,
+    //       generatedColumn: The column number in the generated code,
+    //       source: The path to the original source file that generated this
+    //               chunk of code,
+    //       originalLine: The line number in the original source that
+    //                     corresponds to this chunk of generated code,
+    //       originalColumn: The column number in the original source that
+    //                       corresponds to this chunk of generated code,
+    //       name: The name of the original symbol which generated this chunk of
+    //             code.
+    //     }
+    //
+    // All properties except for `generatedLine` and `generatedColumn` can be
+    // `null`.
+    //
+    // `this._generatedMappings` is ordered by the generated positions.
+    //
+    // `this._originalMappings` is ordered by the original positions.
+    this._generatedMappings = [];
+    this._originalMappings = [];
+    this._parseMappings(mappings, sourceRoot);
+  }
+
+  /**
+   * The version of the source mapping spec that we are consuming.
+   */
+  SourceMapConsumer.prototype._version = 3;
+
+  /**
+   * The list of original sources.
+   */
+  Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
+    get: function () {
+      return this._sources.toArray().map(function (s) {
+        return this.sourceRoot ? util.join(this.sourceRoot, s) : s;
+      }, this);
+    }
+  });
+
+  /**
+   * Parse the mappings in a string in to a data structure which we can easily
+   * query (an ordered list in this._generatedMappings).
+   */
+  SourceMapConsumer.prototype._parseMappings =
+    function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+      var generatedLine = 1;
+      var previousGeneratedColumn = 0;
+      var previousOriginalLine = 0;
+      var previousOriginalColumn = 0;
+      var previousSource = 0;
+      var previousName = 0;
+      var mappingSeparator = /^[,;]/;
+      var str = aStr;
+      var mapping;
+      var temp;
+
+      while (str.length > 0) {
+        if (str.charAt(0) === ';') {
+          generatedLine++;
+          str = str.slice(1);
+          previousGeneratedColumn = 0;
+        }
+        else if (str.charAt(0) === ',') {
+          str = str.slice(1);
+        }
+        else {
+          mapping = {};
+          mapping.generatedLine = generatedLine;
+
+          // Generated column.
+          temp = base64VLQ.decode(str);
+          mapping.generatedColumn = previousGeneratedColumn + temp.value;
+          previousGeneratedColumn = mapping.generatedColumn;
+          str = temp.rest;
+
+          if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
+            // Original source.
+            temp = base64VLQ.decode(str);
+            mapping.source = this._sources.at(previousSource + temp.value);
+            previousSource += temp.value;
+            str = temp.rest;
+            if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
+              throw new Error('Found a source, but no line and column');
+            }
+
+            // Original line.
+            temp = base64VLQ.decode(str);
+            mapping.originalLine = previousOriginalLine + temp.value;
+            previousOriginalLine = mapping.originalLine;
+            // Lines are stored 0-based
+            mapping.originalLine += 1;
+            str = temp.rest;
+            if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
+              throw new Error('Found a source and line, but no column');
+            }
+
+            // Original column.
+            temp = base64VLQ.decode(str);
+            mapping.originalColumn = previousOriginalColumn + temp.value;
+            previousOriginalColumn = mapping.originalColumn;
+            str = temp.rest;
+
+            if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
+              // Original name.
+              temp = base64VLQ.decode(str);
+              mapping.name = this._names.at(previousName + temp.value);
+              previousName += temp.value;
+              str = temp.rest;
+            }
+          }
+
+          this._generatedMappings.push(mapping);
+          if (typeof mapping.originalLine === 'number') {
+            this._originalMappings.push(mapping);
+          }
+        }
+      }
+
+      this._originalMappings.sort(this._compareOriginalPositions);
+    };
+
+  /**
+   * Comparator between two mappings where the original positions are compared.
+   */
+  SourceMapConsumer.prototype._compareOriginalPositions =
+    function SourceMapConsumer_compareOriginalPositions(mappingA, mappingB) {
+      if (mappingA.source > mappingB.source) {
+        return 1;
+      }
+      else if (mappingA.source < mappingB.source) {
+        return -1;
+      }
+      else {
+        var cmp = mappingA.originalLine - mappingB.originalLine;
+        return cmp === 0
+          ? mappingA.originalColumn - mappingB.originalColumn
+          : cmp;
+      }
+    };
+
+  /**
+   * Comparator between two mappings where the generated positions are compared.
+   */
+  SourceMapConsumer.prototype._compareGeneratedPositions =
+    function SourceMapConsumer_compareGeneratedPositions(mappingA, mappingB) {
+      var cmp = mappingA.generatedLine - mappingB.generatedLine;
+      return cmp === 0
+        ? mappingA.generatedColumn - mappingB.generatedColumn
+        : cmp;
+    };
+
+  /**
+   * Find the mapping that best matches the hypothetical "needle" mapping that
+   * we are searching for in the given "haystack" of mappings.
+   */
+  SourceMapConsumer.prototype._findMapping =
+    function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+                                           aColumnName, aComparator) {
+      // To return the position we are searching for, we must first find the
+      // mapping for the given position and then return the opposite position it
+      // points to. Because the mappings are sorted, we can use binary search to
+      // find the best mapping.
+
+      if (aNeedle[aLineName] <= 0) {
+        throw new TypeError('Line must be greater than or equal to 1, got '
+                            + aNeedle[aLineName]);
+      }
+      if (aNeedle[aColumnName] < 0) {
+        throw new TypeError('Column must be greater than or equal to 0, got '
+                            + aNeedle[aColumnName]);
+      }
+
+      return binarySearch.search(aNeedle, aMappings, aComparator);
+    };
+
+  /**
+   * Returns the original source, line, and column information for the generated
+   * source's line and column positions provided. The only argument is an object
+   * with the following properties:
+   *
+   *   - line: The line number in the generated source.
+   *   - column: The column number in the generated source.
+   *
+   * and an object is returned with the following properties:
+   *
+   *   - source: The original source file, or null.
+   *   - line: The line number in the original source, or null.
+   *   - column: The column number in the original source, or null.
+   *   - name: The original identifier, or null.
+   */
+  SourceMapConsumer.prototype.originalPositionFor =
+    function SourceMapConsumer_originalPositionFor(aArgs) {
+      var needle = {
+        generatedLine: util.getArg(aArgs, 'line'),
+        generatedColumn: util.getArg(aArgs, 'column')
+      };
+
+      var mapping = this._findMapping(needle,
+                                      this._generatedMappings,
+                                      "generatedLine",
+                                      "generatedColumn",
+                                      this._compareGeneratedPositions);
+
+      if (mapping) {
+        var source = util.getArg(mapping, 'source', null);
+        if (source && this.sourceRoot) {
+          source = util.join(this.sourceRoot, source);
+        }
+        return {
+          source: source,
+          line: util.getArg(mapping, 'originalLine', null),
+          column: util.getArg(mapping, 'originalColumn', null),
+          name: util.getArg(mapping, 'name', null)
+        };
+      }
+
+      return {
+        source: null,
+        line: null,
+        column: null,
+        name: null
+      };
+    };
+
+  /**
+   * Returns the original source content. The only argument is the url of the
+   * original source file. Returns null if no original source content is
+   * availible.
+   */
+  SourceMapConsumer.prototype.sourceContentFor =
+    function SourceMapConsumer_sourceContentFor(aSource) {
+      if (!this.sourcesContent) {
+        return null;
+      }
+
+      if (this.sourceRoot) {
+        aSource = util.relative(this.sourceRoot, aSource);
+      }
+
+      if (this._sources.has(aSource)) {
+        return this.sourcesContent[this._sources.indexOf(aSource)];
+      }
+
+      var url;
+      if (this.sourceRoot
+          && (url = util.urlParse(this.sourceRoot))) {
+        // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+        // many users. We can help them out when they expect file:// URIs to
+        // behave like it would if they were running a local HTTP server. See
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+        var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
+        if (url.scheme == "file"
+            && this._sources.has(fileUriAbsPath)) {
+          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+        }
+
+        if ((!url.path || url.path == "/")
+            && this._sources.has("/" + aSource)) {
+          return this.sourcesContent[this._sources.indexOf("/" + aSource)];
+        }
+      }
+
+      throw new Error('"' + aSource + '" is not in the SourceMap.');
+    };
+
+  /**
+   * Returns the generated line and column information for the original source,
+   * line, and column positions provided. The only argument is an object with
+   * the following properties:
+   *
+   *   - source: The filename of the original source.
+   *   - line: The line number in the original source.
+   *   - column: The column number in the original source.
+   *
+   * and an object is returned with the following properties:
+   *
+   *   - line: The line number in the generated source, or null.
+   *   - column: The column number in the generated source, or null.
+   */
+  SourceMapConsumer.prototype.generatedPositionFor =
+    function SourceMapConsumer_generatedPositionFor(aArgs) {
+      var needle = {
+        source: util.getArg(aArgs, 'source'),
+        originalLine: util.getArg(aArgs, 'line'),
+        originalColumn: util.getArg(aArgs, 'column')
+      };
+
+      if (this.sourceRoot) {
+        needle.source = util.relative(this.sourceRoot, needle.source);
+      }
+
+      var mapping = this._findMapping(needle,
+                                      this._originalMappings,
+                                      "originalLine",
+                                      "originalColumn",
+                                      this._compareOriginalPositions);
+
+      if (mapping) {
+        return {
+          line: util.getArg(mapping, 'generatedLine', null),
+          column: util.getArg(mapping, 'generatedColumn', null)
+        };
+      }
+
+      return {
+        line: null,
+        column: null
+      };
+    };
+
+  SourceMapConsumer.GENERATED_ORDER = 1;
+  SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+  /**
+   * Iterate over each mapping between an original source/line/column and a
+   * generated line/column in this source map.
+   *
+   * @param Function aCallback
+   *        The function that is called with each mapping.
+   * @param Object aContext
+   *        Optional. If specified, this object will be the value of `this` every
+   *        time that `aCallback` is called.
+   * @param aOrder
+   *        Either `SourceMapConsumer.GENERATED_ORDER` or
+   *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+   *        iterate over the mappings sorted by the generated file's line/column
+   *        order or the original's source/line/column order, respectively. Defaults to
+   *        `SourceMapConsumer.GENERATED_ORDER`.
+   */
+  SourceMapConsumer.prototype.eachMapping =
+    function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+      var context = aContext || null;
+      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+      var mappings;
+      switch (order) {
+      case SourceMapConsumer.GENERATED_ORDER:
+        mappings = this._generatedMappings;
+        break;
+      case SourceMapConsumer.ORIGINAL_ORDER:
+        mappings = this._originalMappings;
+        break;
+      default:
+        throw new Error("Unknown order of iteration.");
+      }
+
+      var sourceRoot = this.sourceRoot;
+      mappings.map(function (mapping) {
+        var source = mapping.source;
+        if (source && sourceRoot) {
+          source = util.join(sourceRoot, source);
+        }
+        return {
+          source: source,
+          generatedLine: mapping.generatedLine,
+          generatedColumn: mapping.generatedColumn,
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name: mapping.name
+        };
+      }).forEach(aCallback, context);
+    };
+
+  exports.SourceMapConsumer = SourceMapConsumer;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/binary-search', ['require', 'exports', 'module' , ], function(require, exports, module) {
+
+  /**
+   * Recursive implementation of binary search.
+   *
+   * @param aLow Indices here and lower do not contain the needle.
+   * @param aHigh Indices here and higher do not contain the needle.
+   * @param aNeedle The element being searched for.
+   * @param aHaystack The non-empty array being searched.
+   * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+   */
+  function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
+    // This function terminates when one of the following is true:
+    //
+    //   1. We find the exact element we are looking for.
+    //
+    //   2. We did not find the exact element, but we can return the next
+    //      closest element that is less than that element.
+    //
+    //   3. We did not find the exact element, and there is no next-closest
+    //      element which is less than the one we are searching for, so we
+    //      return null.
+    var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+    var cmp = aCompare(aNeedle, aHaystack[mid]);
+    if (cmp === 0) {
+      // Found the element we are looking for.
+      return aHaystack[mid];
+    }
+    else if (cmp > 0) {
+      // aHaystack[mid] is greater than our needle.
+      if (aHigh - mid > 1) {
+        // The element is in the upper half.
+        return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
+      }
+      // We did not find an exact match, return the next closest one
+      // (termination case 2).
+      return aHaystack[mid];
+    }
+    else {
+      // aHaystack[mid] is less than our needle.
+      if (mid - aLow > 1) {
+        // The element is in the lower half.
+        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
+      }
+      // The exact needle element was not found in this haystack. Determine if
+      // we are in termination case (2) or (3) and return the appropriate thing.
+      return aLow < 0
+        ? null
+        : aHaystack[aLow];
+    }
+  }
+
+  /**
+   * This is an implementation of binary search which will always try and return
+   * the next lowest value checked if there is no exact hit. This is because
+   * mappings between original and generated line/col pairs are single points,
+   * and there is an implicit region between each of them, so a miss just means
+   * that you aren't on the very start of a region.
+   *
+   * @param aNeedle The element you are looking for.
+   * @param aHaystack The array that is being searched.
+   * @param aCompare A function which takes the needle and an element in the
+   *     array and returns -1, 0, or 1 depending on whether the needle is less
+   *     than, equal to, or greater than the element, respectively.
+   */
+  exports.search = function search(aNeedle, aHaystack, aCompare) {
+    return aHaystack.length > 0
+      ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
+      : null;
+  };
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+define('source-map/source-node', ['require', 'exports', 'module' ,  'source-map/source-map-generator', 'source-map/util'], function(require, exports, module) {
+
+  var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
+  var util = require('./util');
+
+  /**
+   * SourceNodes provide a way to abstract over interpolating/concatenating
+   * snippets of generated JavaScript source code while maintaining the line and
+   * column information associated with the original source code.
+   *
+   * @param aLine The original line number.
+   * @param aColumn The original column number.
+   * @param aSource The original source's filename.
+   * @param aChunks Optional. An array of strings which are snippets of
+   *        generated JS, or other SourceNodes.
+   * @param aName The original identifier.
+   */
+  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+    this.children = [];
+    this.sourceContents = {};
+    this.line = aLine === undefined ? null : aLine;
+    this.column = aColumn === undefined ? null : aColumn;
+    this.source = aSource === undefined ? null : aSource;
+    this.name = aName === undefined ? null : aName;
+    if (aChunks != null) this.add(aChunks);
+  }
+
+  /**
+   * Creates a SourceNode from generated code and a SourceMapConsumer.
+   *
+   * @param aGeneratedCode The generated code
+   * @param aSourceMapConsumer The SourceMap for the generated code
+   */
+  SourceNode.fromStringWithSourceMap =
+    function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) {
+      // The SourceNode we want to fill with the generated code
+      // and the SourceMap
+      var node = new SourceNode();
+
+      // The generated code
+      // Processed fragments are removed from this array.
+      var remainingLines = aGeneratedCode.split('\n');
+
+      // We need to remember the position of "remainingLines"
+      var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+      // The generate SourceNodes we need a code range.
+      // To extract it current and last mapping is used.
+      // Here we store the last mapping.
+      var lastMapping = null;
+
+      aSourceMapConsumer.eachMapping(function (mapping) {
+        if (lastMapping === null) {
+          // We add the generated code until the first mapping
+          // to the SourceNode without any mapping.
+          // Each line is added as separate string.
+          while (lastGeneratedLine < mapping.generatedLine) {
+            node.add(remainingLines.shift() + "\n");
+            lastGeneratedLine++;
+          }
+          if (lastGeneratedColumn < mapping.generatedColumn) {
+            var nextLine = remainingLines[0];
+            node.add(nextLine.substr(0, mapping.generatedColumn));
+            remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+            lastGeneratedColumn = mapping.generatedColumn;
+          }
+        } else {
+          // We add the code from "lastMapping" to "mapping":
+          // First check if there is a new line in between.
+          if (lastGeneratedLine < mapping.generatedLine) {
+            var code = "";
+            // Associate full lines with "lastMapping"
+            do {
+              code += remainingLines.shift() + "\n";
+              lastGeneratedLine++;
+              lastGeneratedColumn = 0;
+            } while (lastGeneratedLine < mapping.generatedLine);
+            // When we reached the correct line, we add code until we
+            // reach the correct column too.
+            if (lastGeneratedColumn < mapping.generatedColumn) {
+              var nextLine = remainingLines[0];
+              code += nextLine.substr(0, mapping.generatedColumn);
+              remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+              lastGeneratedColumn = mapping.generatedColumn;
+            }
+            // Create the SourceNode.
+            addMappingWithCode(lastMapping, code);
+          } else {
+            // There is no new line in between.
+            // Associate the code between "lastGeneratedColumn" and
+            // "mapping.generatedColumn" with "lastMapping"
+            var nextLine = remainingLines[0];
+            var code = nextLine.substr(0, mapping.generatedColumn -
+                                          lastGeneratedColumn);
+            remainingLines[0] = nextLine.substr(mapping.generatedColumn -
+                                                lastGeneratedColumn);
+            lastGeneratedColumn = mapping.generatedColumn;
+            addMappingWithCode(lastMapping, code);
+          }
+        }
+        lastMapping = mapping;
+      }, this);
+      // We have processed all mappings.
+      // Associate the remaining code in the current line with "lastMapping"
+      // and add the remaining lines without any mapping
+      addMappingWithCode(lastMapping, remainingLines.join("\n"));
+
+      // Copy sourcesContent into SourceNode
+      aSourceMapConsumer.sources.forEach(function (sourceFile) {
+        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+        if (content) {
+          node.setSourceContent(sourceFile, content);
+        }
+      });
+
+      return node;
+
+      function addMappingWithCode(mapping, code) {
+        if (mapping.source === undefined) {
+          node.add(code);
+        } else {
+          node.add(new SourceNode(mapping.originalLine,
+                                  mapping.originalColumn,
+                                  mapping.source,
+                                  code,
+                                  mapping.name));
+        }
+      }
+    };
+
+  /**
+   * Add a chunk of generated JS to this source node.
+   *
+   * @param aChunk A string snippet of generated JS code, another instance of
+   *        SourceNode, or an array where each member is one of those things.
+   */
+  SourceNode.prototype.add = function SourceNode_add(aChunk) {
+    if (Array.isArray(aChunk)) {
+      aChunk.forEach(function (chunk) {
+        this.add(chunk);
+      }, this);
+    }
+    else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
+      if (aChunk) {
+        this.children.push(aChunk);
+      }
+    }
+    else {
+      throw new TypeError(
+        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+      );
+    }
+    return this;
+  };
+
+  /**
+   * Add a chunk of generated JS to the beginning of this source node.
+   *
+   * @param aChunk A string snippet of generated JS code, another instance of
+   *        SourceNode, or an array where each member is one of those things.
+   */
+  SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+    if (Array.isArray(aChunk)) {
+      for (var i = aChunk.length-1; i >= 0; i--) {
+        this.prepend(aChunk[i]);
+      }
+    }
+    else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
+      this.children.unshift(aChunk);
+    }
+    else {
+      throw new TypeError(
+        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+      );
+    }
+    return this;
+  };
+
+  /**
+   * Walk over the tree of JS snippets in this node and its children. The
+   * walking function is called once for each snippet of JS and is passed that
+   * snippet and the its original associated source's line/column location.
+   *
+   * @param aFn The traversal function.
+   */
+  SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+    this.children.forEach(function (chunk) {
+      if (chunk instanceof SourceNode) {
+        chunk.walk(aFn);
+      }
+      else {
+        if (chunk !== '') {
+          aFn(chunk, { source: this.source,
+                       line: this.line,
+                       column: this.column,
+                       name: this.name });
+        }
+      }
+    }, this);
+  };
+
+  /**
+   * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+   * each of `this.children`.
+   *
+   * @param aSep The separator.
+   */
+  SourceNode.prototype.join = function SourceNode_join(aSep) {
+    var newChildren;
+    var i;
+    var len = this.children.length;
+    if (len > 0) {
+      newChildren = [];
+      for (i = 0; i < len-1; i++) {
+        newChildren.push(this.children[i]);
+        newChildren.push(aSep);
+      }
+      newChildren.push(this.children[i]);
+      this.children = newChildren;
+    }
+    return this;
+  };
+
+  /**
+   * Call String.prototype.replace on the very right-most source snippet. Useful
+   * for trimming whitespace from the end of a source node, etc.
+   *
+   * @param aPattern The pattern to replace.
+   * @param aReplacement The thing to replace the pattern with.
+   */
+  SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+    var lastChild = this.children[this.children.length - 1];
+    if (lastChild instanceof SourceNode) {
+      lastChild.replaceRight(aPattern, aReplacement);
+    }
+    else if (typeof lastChild === 'string') {
+      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+    }
+    else {
+      this.children.push(''.replace(aPattern, aReplacement));
+    }
+    return this;
+  };
+
+  /**
+   * Set the source content for a source file. This will be added to the SourceMapGenerator
+   * in the sourcesContent field.
+   *
+   * @param aSourceFile The filename of the source file
+   * @param aSourceContent The content of the source file
+   */
+  SourceNode.prototype.setSourceContent =
+    function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+      this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+    };
+
+  /**
+   * Walk over the tree of SourceNodes. The walking function is called for each
+   * source file content and is passed the filename and source content.
+   *
+   * @param aFn The traversal function.
+   */
+  SourceNode.prototype.walkSourceContents =
+    function SourceNode_walkSourceContents(aFn) {
+      this.children.forEach(function (chunk) {
+        if (chunk instanceof SourceNode) {
+          chunk.walkSourceContents(aFn);
+        }
+      }, this);
+      Object.keys(this.sourceContents).forEach(function (sourceFileKey) {
+        aFn(util.fromSetString(sourceFileKey), this.sourceContents[sourceFileKey]);
+      }, this);
+    };
+
+  /**
+   * Return the string representation of this source node. Walks over the tree
+   * and concatenates all the various snippets together to one string.
+   */
+  SourceNode.prototype.toString = function SourceNode_toString() {
+    var str = "";
+    this.walk(function (chunk) {
+      str += chunk;
+    });
+    return str;
+  };
+
+  /**
+   * Returns the string representation of this source node along with a source
+   * map.
+   */
+  SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+    var generated = {
+      code: "",
+      line: 1,
+      column: 0
+    };
+    var map = new SourceMapGenerator(aArgs);
+    var sourceMappingActive = false;
+    this.walk(function (chunk, original) {
+      generated.code += chunk;
+      if (original.source !== null
+          && original.line !== null
+          && original.column !== null) {
+        map.addMapping({
+          source: original.source,
+          original: {
+            line: original.line,
+            column: original.column
+          },
+          generated: {
+            line: generated.line,
+            column: generated.column
+          },
+          name: original.name
+        });
+        sourceMappingActive = true;
+      } else if (sourceMappingActive) {
+        map.addMapping({
+          generated: {
+            line: generated.line,
+            column: generated.column
+          }
+        });
+        sourceMappingActive = false;
+      }
+      chunk.split('').forEach(function (ch) {
+        if (ch === '\n') {
+          generated.line++;
+          generated.column = 0;
+        } else {
+          generated.column++;
+        }
+      });
+    });
+    this.walkSourceContents(function (sourceFile, sourceContent) {
+      map.setSourceContent(sourceFile, sourceContent);
+    });
+
+    return { code: generated.code, map: map };
+  };
+
+  exports.SourceNode = SourceNode;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+///////////////////////////////////////////////////////////////////////////////
+
+window.sourceMap = {
+  SourceMapConsumer: require('source-map/source-map-consumer').SourceMapConsumer,
+  SourceMapGenerator: require('source-map/source-map-generator').SourceMapGenerator,
+  SourceNode: require('source-map/source-node').SourceNode
+};
+MOZ_SourceMap = sourceMap;(function(exports,global){global["UglifyJS"]=exports;/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function array_to_hash(a){var ret=Object.create(null);for(var i=0;i<a.length;++i)ret[a[i]]=true;return ret}function slice(a,start){return Array.prototype.slice.call(a,start||0)}function characters(str){return str.split("")}function member(name,array){for(var i=array.length;--i>=0;)if(array[i]==name)return true;return false}function find_if(func,array){for(var i=0,n=array.length;i<n;++i){if(func(array[i]))return array[i]}}function repeat_string(str,i){if(i<=0)return"";if(i==1)return str;var d=repeat_string(str,i>>1);d+=d;if(i&1)d+=str;return d}function DefaultsError(msg,defs){Error.call(this,msg);this.msg=msg;this.defs=defs}DefaultsError.prototype=Object.create(Error.prototype);DefaultsError.prototype.constructor=DefaultsError;DefaultsError.croak=function(msg,defs){throw new DefaultsError(msg,defs)};function defaults(args,defs,croak){if(args===true)args={};var ret=args||{};if(croak)for(var i in ret)if(ret.hasOwnProperty(i)&&!defs.hasOwnProperty(i))DefaultsError.croak("`"+i+"` is not a supported option",defs);for(var i in defs)if(defs.hasOwnProperty(i)){ret[i]=args&&args.hasOwnProperty(i)?args[i]:defs[i]}return ret}function merge(obj,ext){for(var i in ext)if(ext.hasOwnProperty(i)){obj[i]=ext[i]}return obj}function noop(){}var MAP=function(){function MAP(a,f,backwards){var ret=[],top=[],i;function doit(){var val=f(a[i],i);var is_last=val instanceof Last;if(is_last)val=val.v;if(val instanceof AtTop){val=val.v;if(val instanceof Splice){top.push.apply(top,backwards?val.v.slice().reverse():val.v)}else{top.push(val)}}else if(val!==skip){if(val instanceof Splice){ret.push.apply(ret,backwards?val.v.slice().reverse():val.v)}else{ret.push(val)}}return is_last}if(a instanceof Array){if(backwards){for(i=a.length;--i>=0;)if(doit())break;ret.reverse();top.reverse()}else{for(i=0;i<a.length;++i)if(doit())break}}else{for(i in a)if(a.hasOwnProperty(i))if(doit())break}return top.concat(ret)}MAP.at_top=function(val){return new AtTop(val)};MAP.splice=function(val){return new Splice(val)};MAP.last=function(val){return new Last(val)};var skip=MAP.skip={};function AtTop(val){this.v=val}function Splice(val){this.v=val}function Last(val){this.v=val}return MAP}();function push_uniq(array,el){if(array.indexOf(el)<0)array.push(el)}function string_template(text,props){return text.replace(/\{(.+?)\}/g,function(str,p){return props[p]})}function remove(array,el){for(var i=array.length;--i>=0;){if(array[i]===el)array.splice(i,1)}}function mergeSort(array,cmp){if(array.length<2)return array.slice();function merge(a,b){var r=[],ai=0,bi=0,i=0;while(ai<a.length&&bi<b.length){cmp(a[ai],b[bi])<=0?r[i++]=a[ai++]:r[i++]=b[bi++]}if(ai<a.length)r.push.apply(r,a.slice(ai));if(bi<b.length)r.push.apply(r,b.slice(bi));return r}function _ms(a){if(a.length<=1)return a;var m=Math.floor(a.length/2),left=a.slice(0,m),right=a.slice(m);left=_ms(left);right=_ms(right);return merge(left,right)}return _ms(array)}function set_difference(a,b){return a.filter(function(el){return b.indexOf(el)<0})}function set_intersection(a,b){return a.filter(function(el){return b.indexOf(el)>=0})}function makePredicate(words){if(!(words instanceof Array))words=words.split(" ");var f="",cats=[];out:for(var i=0;i<words.length;++i){for(var j=0;j<cats.length;++j)if(cats[j][0].length==words[i].length){cats[j].push(words[i]);continue out}cats.push([words[i]])}function compareTo(arr){if(arr.length==1)return f+="return str === "+JSON.stringify(arr[0])+";";f+="switch(str){";for(var i=0;i<arr.length;++i)f+="case "+JSON.stringify(arr[i])+":";f+="return true}return false;"}if(cats.length>3){cats.sort(function(a,b){return b.length-a.length});f+="switch(str.length){";for(var i=0;i<cats.length;++i){var cat=cats[i];f+="case "+cat[0].length+":";compareTo(cat)}f+="}"}else{compareTo(words)}return new Function("str",f)}function all(array,predicate){for(var i=array.length;--i>=0;)if(!predicate(array[i]))return false;return true}function Dictionary(){this._values=Object.create(null);this._size=0}Dictionary.prototype={set:function(key,val){if(!this.has(key))++this._size;this._values["$"+key]=val;return this},add:function(key,val){if(this.has(key)){this.get(key).push(val)}else{this.set(key,[val])}return this},get:function(key){return this._values["$"+key]},del:function(key){if(this.has(key)){--this._size;delete this._values["$"+key]}return this},has:function(key){return"$"+key in this._values},each:function(f){for(var i in this._values)f(this._values[i],i.substr(1))},size:function(){return this._size},map:function(f){var ret=[];for(var i in this._values)ret.push(f(this._values[i],i.substr(1)));return ret}};/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function DEFNODE(type,props,methods,base){if(arguments.length<4)base=AST_Node;if(!props)props=[];else props=props.split(/\s+/);var self_props=props;if(base&&base.PROPS)props=props.concat(base.PROPS);var code="return function AST_"+type+"(props){ if (props) { ";for(var i=props.length;--i>=0;){code+="this."+props[i]+" = props."+props[i]+";"}var proto=base&&new base;if(proto&&proto.initialize||methods&&methods.initialize)code+="this.initialize();";code+="}}";var ctor=new Function(code)();if(proto){ctor.prototype=proto;ctor.BASE=base}if(base)base.SUBCLASSES.push(ctor);ctor.prototype.CTOR=ctor;ctor.PROPS=props||null;ctor.SELF_PROPS=self_props;ctor.SUBCLASSES=[];if(type){ctor.prototype.TYPE=ctor.TYPE=type}if(methods)for(i in methods)if(methods.hasOwnProperty(i)){if(/^\$/.test(i)){ctor[i.substr(1)]=methods[i]}else{ctor.prototype[i]=methods[i]}}ctor.DEFMETHOD=function(name,method){this.prototype[name]=method};return ctor}var AST_Token=DEFNODE("Token","type value line col pos endpos nlb comments_before file",{},null);var AST_Node=DEFNODE("Node","start end",{clone:function(){return new this.CTOR(this)},$documentation:"Base class of all AST nodes",$propdoc:{start:"[AST_Token] The first token of this node",end:"[AST_Token] The last token of this node"},_walk:function(visitor){return visitor._visit(this)},walk:function(visitor){return this._walk(visitor)}},null);AST_Node.warn_function=null;AST_Node.warn=function(txt,props){if(AST_Node.warn_function)AST_Node.warn_function(string_template(txt,props))};var AST_Statement=DEFNODE("Statement",null,{$documentation:"Base class of all statements"});var AST_Debugger=DEFNODE("Debugger",null,{$documentation:"Represents a debugger statement"},AST_Statement);var AST_Directive=DEFNODE("Directive","value scope",{$documentation:'Represents a directive, like "use strict";',$propdoc:{value:"[string] The value of this directive as a plain string (it's not an AST_String!)",scope:"[AST_Scope/S] The scope that this directive affects"}},AST_Statement);var AST_SimpleStatement=DEFNODE("SimpleStatement","body",{$documentation:"A statement consisting of an expression, i.e. a = 1 + 2",$propdoc:{body:"[AST_Node] an expression node (should not be instanceof AST_Statement)"},_walk:function(visitor){return visitor._visit(this,function(){this.body._walk(visitor)})}},AST_Statement);function walk_body(node,visitor){if(node.body instanceof AST_Statement){node.body._walk(visitor)}else node.body.forEach(function(stat){stat._walk(visitor)})}var AST_Block=DEFNODE("Block","body",{$documentation:"A body of statements (usually bracketed)",$propdoc:{body:"[AST_Statement*] an array of statements"},_walk:function(visitor){return visitor._visit(this,function(){walk_body(this,visitor)})}},AST_Statement);var AST_BlockStatement=DEFNODE("BlockStatement",null,{$documentation:"A block statement"},AST_Block);var AST_EmptyStatement=DEFNODE("EmptyStatement",null,{$documentation:"The empty statement (empty block or simply a semicolon)",_walk:function(visitor){return visitor._visit(this)}},AST_Statement);var AST_StatementWithBody=DEFNODE("StatementWithBody","body",{$documentation:"Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",$propdoc:{body:"[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"},_walk:function(visitor){return visitor._visit(this,function(){this.body._walk(visitor)})}},AST_Statement);var AST_LabeledStatement=DEFNODE("LabeledStatement","label",{$documentation:"Statement with a label",$propdoc:{label:"[AST_Label] a label definition"},_walk:function(visitor){return visitor._visit(this,function(){this.label._walk(visitor);this.body._walk(visitor)})}},AST_StatementWithBody);var AST_IterationStatement=DEFNODE("IterationStatement",null,{$documentation:"Internal class.  All loops inherit from it."},AST_StatementWithBody);var AST_DWLoop=DEFNODE("DWLoop","condition",{$documentation:"Base class for do/while statements",$propdoc:{condition:"[AST_Node] the loop condition.  Should not be instanceof AST_Statement"},_walk:function(visitor){return visitor._visit(this,function(){this.condition._walk(visitor);this.body._walk(visitor)})}},AST_IterationStatement);var AST_Do=DEFNODE("Do",null,{$documentation:"A `do` statement"},AST_DWLoop);var AST_While=DEFNODE("While",null,{$documentation:"A `while` statement"},AST_DWLoop);var AST_For=DEFNODE("For","init condition step",{$documentation:"A `for` statement",$propdoc:{init:"[AST_Node?] the `for` initialization code, or null if empty",condition:"[AST_Node?] the `for` termination clause, or null if empty",step:"[AST_Node?] the `for` update clause, or null if empty"},_walk:function(visitor){return visitor._visit(this,function(){if(this.init)this.init._walk(visitor);if(this.condition)this.condition._walk(visitor);if(this.step)this.step._walk(visitor);this.body._walk(visitor)})}},AST_IterationStatement);var AST_ForIn=DEFNODE("ForIn","init name object",{$documentation:"A `for ... in` statement",$propdoc:{init:"[AST_Node] the `for/in` initialization code",name:"[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",object:"[AST_Node] the object that we're looping through"},_walk:function(visitor){return visitor._visit(this,function(){this.init._walk(visitor);this.object._walk(visitor);this.body._walk(visitor)})}},AST_IterationStatement);var AST_With=DEFNODE("With","expression",{$documentation:"A `with` statement",$propdoc:{expression:"[AST_Node] the `with` expression"},_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor);this.body._walk(visitor)})}},AST_StatementWithBody);var AST_Scope=DEFNODE("Scope","directives variables functions uses_with uses_eval parent_scope enclosed cname",{$documentation:"Base class for all statements introducing a lexical scope",$propdoc:{directives:"[string*/S] an array of directives declared in this scope",variables:"[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",functions:"[Object/S] like `variables`, but only lists function declarations",uses_with:"[boolean/S] tells whether this scope uses the `with` statement",uses_eval:"[boolean/S] tells whether this scope contains a direct call to the global `eval`",parent_scope:"[AST_Scope?/S] link to the parent scope",enclosed:"[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",cname:"[integer/S] current index for mangling variables (used internally by the mangler)"}},AST_Block);var AST_Toplevel=DEFNODE("Toplevel","globals",{$documentation:"The toplevel scope",$propdoc:{globals:"[Object/S] a map of name -> SymbolDef for all undeclared names"},wrap_enclose:function(arg_parameter_pairs){var self=this;var args=[];var parameters=[];arg_parameter_pairs.forEach(function(pair){var splitAt=pair.lastIndexOf(":");args.push(pair.substr(0,splitAt));parameters.push(pair.substr(splitAt+1))});var wrapped_tl="(function("+parameters.join(",")+"){ '$ORIG'; })("+args.join(",")+")";wrapped_tl=parse(wrapped_tl);wrapped_tl=wrapped_tl.transform(new TreeTransformer(function before(node){if(node instanceof AST_Directive&&node.value=="$ORIG"){return MAP.splice(self.body)}}));return wrapped_tl},wrap_commonjs:function(name,export_all){var self=this;var to_export=[];if(export_all){self.figure_out_scope();self.walk(new TreeWalker(function(node){if(node instanceof AST_SymbolDeclaration&&node.definition().global){if(!find_if(function(n){return n.name==node.name},to_export))to_export.push(node)}}))}var wrapped_tl="(function(exports, global){ global['"+name+"'] = exports; '$ORIG'; '$EXPORTS'; }({}, (function(){return this}())))";wrapped_tl=parse(wrapped_tl);wrapped_tl=wrapped_tl.transform(new TreeTransformer(function before(node){if(node instanceof AST_SimpleStatement){node=node.body;if(node instanceof AST_String)switch(node.getValue()){case"$ORIG":return MAP.splice(self.body);case"$EXPORTS":var body=[];to_export.forEach(function(sym){body.push(new AST_SimpleStatement({body:new AST_Assign({left:new AST_Sub({expression:new AST_SymbolRef({name:"exports"}),property:new AST_String({value:sym.name})}),operator:"=",right:new AST_SymbolRef(sym)})}))});return MAP.splice(body)}}}));return wrapped_tl}},AST_Scope);var AST_Lambda=DEFNODE("Lambda","name argnames uses_arguments",{$documentation:"Base class for functions",$propdoc:{name:"[AST_SymbolDeclaration?] the name of this function",argnames:"[AST_SymbolFunarg*] array of function arguments",uses_arguments:"[boolean/S] tells whether this function accesses the arguments array"},_walk:function(visitor){return visitor._visit(this,function(){if(this.name)this.name._walk(visitor);this.argnames.forEach(function(arg){arg._walk(visitor)});walk_body(this,visitor)})}},AST_Scope);var AST_Accessor=DEFNODE("Accessor",null,{$documentation:"A setter/getter function.  The `name` property is always null."},AST_Lambda);var AST_Function=DEFNODE("Function",null,{$documentation:"A function expression"},AST_Lambda);var AST_Defun=DEFNODE("Defun",null,{$documentation:"A function definition"},AST_Lambda);var AST_Jump=DEFNODE("Jump",null,{$documentation:"Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"},AST_Statement);var AST_Exit=DEFNODE("Exit","value",{$documentation:"Base class for “exits” (`return` and `throw`)",$propdoc:{value:"[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"},_walk:function(visitor){return visitor._visit(this,this.value&&function(){this.value._walk(visitor)})}},AST_Jump);var AST_Return=DEFNODE("Return",null,{$documentation:"A `return` statement"},AST_Exit);var AST_Throw=DEFNODE("Throw",null,{$documentation:"A `throw` statement"},AST_Exit);var AST_LoopControl=DEFNODE("LoopControl","label",{$documentation:"Base class for loop control statements (`break` and `continue`)",$propdoc:{label:"[AST_LabelRef?] the label, or null if none"},_walk:function(visitor){return visitor._visit(this,this.label&&function(){this.label._walk(visitor)})}},AST_Jump);var AST_Break=DEFNODE("Break",null,{$documentation:"A `break` statement"},AST_LoopControl);var AST_Continue=DEFNODE("Continue",null,{$documentation:"A `continue` statement"},AST_LoopControl);var AST_If=DEFNODE("If","condition alternative",{$documentation:"A `if` statement",$propdoc:{condition:"[AST_Node] the `if` condition",alternative:"[AST_Statement?] the `else` part, or null if not present"},_walk:function(visitor){return visitor._visit(this,function(){this.condition._walk(visitor);this.body._walk(visitor);if(this.alternative)this.alternative._walk(visitor)})}},AST_StatementWithBody);var AST_Switch=DEFNODE("Switch","expression",{$documentation:"A `switch` statement",$propdoc:{expression:"[AST_Node] the `switch` “discriminant”"},_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor);walk_body(this,visitor)})}},AST_Block);var AST_SwitchBranch=DEFNODE("SwitchBranch",null,{$documentation:"Base class for `switch` branches"},AST_Block);var AST_Default=DEFNODE("Default",null,{$documentation:"A `default` switch branch"},AST_SwitchBranch);var AST_Case=DEFNODE("Case","expression",{$documentation:"A `case` switch branch",$propdoc:{expression:"[AST_Node] the `case` expression"},_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor);walk_body(this,visitor)})}},AST_SwitchBranch);var AST_Try=DEFNODE("Try","bcatch bfinally",{$documentation:"A `try` statement",$propdoc:{bcatch:"[AST_Catch?] the catch block, or null if not present",bfinally:"[AST_Finally?] the finally block, or null if not present"},_walk:function(visitor){return visitor._visit(this,function(){walk_body(this,visitor);if(this.bcatch)this.bcatch._walk(visitor);if(this.bfinally)this.bfinally._walk(visitor)})}},AST_Block);var AST_Catch=DEFNODE("Catch","argname",{$documentation:"A `catch` node; only makes sense as part of a `try` statement",$propdoc:{argname:"[AST_SymbolCatch] symbol for the exception"},_walk:function(visitor){return visitor._visit(this,function(){this.argname._walk(visitor);walk_body(this,visitor)})}},AST_Block);var AST_Finally=DEFNODE("Finally",null,{$documentation:"A `finally` node; only makes sense as part of a `try` statement"},AST_Block);var AST_Definitions=DEFNODE("Definitions","definitions",{$documentation:"Base class for `var` or `const` nodes (variable declarations/initializations)",$propdoc:{definitions:"[AST_VarDef*] array of variable definitions"},_walk:function(visitor){return visitor._visit(this,function(){this.definitions.forEach(function(def){def._walk(visitor)})})}},AST_Statement);var AST_Var=DEFNODE("Var",null,{$documentation:"A `var` statement"},AST_Definitions);var AST_Const=DEFNODE("Const",null,{$documentation:"A `const` statement"},AST_Definitions);var AST_VarDef=DEFNODE("VarDef","name value",{$documentation:"A variable declaration; only appears in a AST_Definitions node",$propdoc:{name:"[AST_SymbolVar|AST_SymbolConst] name of the variable",value:"[AST_Node?] initializer, or null of there's no initializer"},_walk:function(visitor){return visitor._visit(this,function(){this.name._walk(visitor);if(this.value)this.value._walk(visitor)})}});var AST_Call=DEFNODE("Call","expression args",{$documentation:"A function call expression",$propdoc:{expression:"[AST_Node] expression to invoke as function",args:"[AST_Node*] array of arguments"},_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor);this.args.forEach(function(arg){arg._walk(visitor)})})}});var AST_New=DEFNODE("New",null,{$documentation:"An object instantiation.  Derives from a function call since it has exactly the same properties"},AST_Call);var AST_Seq=DEFNODE("Seq","car cdr",{$documentation:"A sequence expression (two comma-separated expressions)",$propdoc:{car:"[AST_Node] first element in sequence",cdr:"[AST_Node] second element in sequence"},$cons:function(x,y){var seq=new AST_Seq(x);seq.car=x;seq.cdr=y;return seq},$from_array:function(array){if(array.length==0)return null;if(array.length==1)return array[0].clone();var list=null;for(var i=array.length;--i>=0;){list=AST_Seq.cons(array[i],list)}var p=list;while(p){if(p.cdr&&!p.cdr.cdr){p.cdr=p.cdr.car;break}p=p.cdr}return list},to_array:function(){var p=this,a=[];while(p){a.push(p.car);if(p.cdr&&!(p.cdr instanceof AST_Seq)){a.push(p.cdr);break}p=p.cdr}return a},add:function(node){var p=this;while(p){if(!(p.cdr instanceof AST_Seq)){var cell=AST_Seq.cons(p.cdr,node);return p.cdr=cell}p=p.cdr}},_walk:function(visitor){return visitor._visit(this,function(){this.car._walk(visitor);if(this.cdr)this.cdr._walk(visitor)})}});var AST_PropAccess=DEFNODE("PropAccess","expression property",{$documentation:'Base class for property access expressions, i.e. `a.foo` or `a["foo"]`',$propdoc:{expression:"[AST_Node] the “container” expression",property:"[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node"}});var AST_Dot=DEFNODE("Dot",null,{$documentation:"A dotted property access expression",_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor)})}},AST_PropAccess);var AST_Sub=DEFNODE("Sub",null,{$documentation:'Index-style property access, i.e. `a["foo"]`',_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor);this.property._walk(visitor)})}},AST_PropAccess);var AST_Unary=DEFNODE("Unary","operator expression",{$documentation:"Base class for unary expressions",$propdoc:{operator:"[string] the operator",expression:"[AST_Node] expression that this unary operator applies to"},_walk:function(visitor){return visitor._visit(this,function(){this.expression._walk(visitor)})}});var AST_UnaryPrefix=DEFNODE("UnaryPrefix",null,{$documentation:"Unary prefix expression, i.e. `typeof i` or `++i`"},AST_Unary);var AST_UnaryPostfix=DEFNODE("UnaryPostfix",null,{$documentation:"Unary postfix expression, i.e. `i++`"},AST_Unary);var AST_Binary=DEFNODE("Binary","left operator right",{$documentation:"Binary expression, i.e. `a + b`",$propdoc:{left:"[AST_Node] left-hand side expression",operator:"[string] the operator",right:"[AST_Node] right-hand side expression"},_walk:function(visitor){return visitor._visit(this,function(){this.left._walk(visitor);this.right._walk(visitor)})}});var AST_Conditional=DEFNODE("Conditional","condition consequent alternative",{$documentation:"Conditional expression using the ternary operator, i.e. `a ? b : c`",$propdoc:{condition:"[AST_Node]",consequent:"[AST_Node]",alternative:"[AST_Node]"},_walk:function(visitor){return visitor._visit(this,function(){this.condition._walk(visitor);this.consequent._walk(visitor);this.alternative._walk(visitor)})}});var AST_Assign=DEFNODE("Assign",null,{$documentation:"An assignment expression — `a = b + 5`"},AST_Binary);var AST_Array=DEFNODE("Array","elements",{$documentation:"An array literal",$propdoc:{elements:"[AST_Node*] array of elements"},_walk:function(visitor){return visitor._visit(this,function(){this.elements.forEach(function(el){el._walk(visitor)})})}});var AST_Object=DEFNODE("Object","properties",{$documentation:"An object literal",$propdoc:{properties:"[AST_ObjectProperty*] array of properties"},_walk:function(visitor){return visitor._visit(this,function(){this.properties.forEach(function(prop){prop._walk(visitor)})})}});var AST_ObjectProperty=DEFNODE("ObjectProperty","key value",{$documentation:"Base class for literal object properties",$propdoc:{key:"[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an arbitrary AST_Node.",value:"[AST_Node] property value.  For setters and getters this is an AST_Function."},_walk:function(visitor){return visitor._visit(this,function(){this.value._walk(visitor)})}});var AST_ObjectKeyVal=DEFNODE("ObjectKeyVal",null,{$documentation:"A key: value object property"},AST_ObjectProperty);var AST_ObjectSetter=DEFNODE("ObjectSetter",null,{$documentation:"An object setter property"},AST_ObjectProperty);var AST_ObjectGetter=DEFNODE("ObjectGetter",null,{$documentation:"An object getter property"},AST_ObjectProperty);var AST_Symbol=DEFNODE("Symbol","scope name thedef",{$propdoc:{name:"[string] name of this symbol",scope:"[AST_Scope/S] the current scope (not necessarily the definition scope)",thedef:"[SymbolDef/S] the definition of this symbol"},$documentation:"Base class for all symbols"});var AST_SymbolAccessor=DEFNODE("SymbolAccessor",null,{$documentation:"The name of a property accessor (setter/getter function)"},AST_Symbol);var AST_SymbolDeclaration=DEFNODE("SymbolDeclaration","init",{$documentation:"A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",$propdoc:{init:"[AST_Node*/S] array of initializers for this declaration."}},AST_Symbol);var AST_SymbolVar=DEFNODE("SymbolVar",null,{$documentation:"Symbol defining a variable"},AST_SymbolDeclaration);var AST_SymbolConst=DEFNODE("SymbolConst",null,{$documentation:"A constant declaration"},AST_SymbolDeclaration);var AST_SymbolFunarg=DEFNODE("SymbolFunarg",null,{$documentation:"Symbol naming a function argument"},AST_SymbolVar);var AST_SymbolDefun=DEFNODE("SymbolDefun",null,{$documentation:"Symbol defining a function"},AST_SymbolDeclaration);var AST_SymbolLambda=DEFNODE("SymbolLambda",null,{$documentation:"Symbol naming a function expression"},AST_SymbolDeclaration);var AST_SymbolCatch=DEFNODE("SymbolCatch",null,{$documentation:"Symbol naming the exception in catch"},AST_SymbolDeclaration);var AST_Label=DEFNODE("Label","references",{$documentation:"Symbol naming a label (declaration)",$propdoc:{references:"[AST_LoopControl*] a list of nodes referring to this label"},initialize:function(){this.references=[];this.thedef=this}},AST_Symbol);var AST_SymbolRef=DEFNODE("SymbolRef",null,{$documentation:"Reference to some symbol (not definition/declaration)"},AST_Symbol);var AST_LabelRef=DEFNODE("LabelRef",null,{$documentation:"Reference to a label symbol"},AST_Symbol);var AST_This=DEFNODE("This",null,{$documentation:"The `this` symbol"},AST_Symbol);var AST_Constant=DEFNODE("Constant",null,{$documentation:"Base class for all constants",getValue:function(){return this.value}});var AST_String=DEFNODE("String","value",{$documentation:"A string literal",$propdoc:{value:"[string] the contents of this string"}},AST_Constant);var AST_Number=DEFNODE("Number","value",{$documentation:"A number literal",$propdoc:{value:"[number] the numeric value"}},AST_Constant);var AST_RegExp=DEFNODE("RegExp","value",{$documentation:"A regexp literal",$propdoc:{value:"[RegExp] the actual regexp"}},AST_Constant);var AST_Atom=DEFNODE("Atom",null,{$documentation:"Base class for atoms"},AST_Constant);var AST_Null=DEFNODE("Null",null,{$documentation:"The `null` atom",value:null},AST_Atom);var AST_NaN=DEFNODE("NaN",null,{$documentation:"The impossible value",value:0/0},AST_Atom);var AST_Undefined=DEFNODE("Undefined",null,{$documentation:"The `undefined` value",value:function(){}()},AST_Atom);var AST_Hole=DEFNODE("Hole",null,{$documentation:"A hole in an array",value:function(){}()},AST_Atom);var AST_Infinity=DEFNODE("Infinity",null,{$documentation:"The `Infinity` value",value:1/0},AST_Atom);var AST_Boolean=DEFNODE("Boolean",null,{$documentation:"Base class for booleans"},AST_Atom);var AST_False=DEFNODE("False",null,{$documentation:"The `false` atom",value:false},AST_Boolean);var AST_True=DEFNODE("True",null,{$documentation:"The `true` atom",value:true},AST_Boolean);function TreeWalker(callback){this.visit=callback;this.stack=[]}TreeWalker.prototype={_visit:function(node,descend){this.stack.push(node);var ret=this.visit(node,descend?function(){descend.call(node)}:noop);if(!ret&&descend){descend.call(node)}this.stack.pop();return ret},parent:function(n){return this.stack[this.stack.length-2-(n||0)]},push:function(node){this.stack.push(node)},pop:function(){return this.stack.pop()},self:function(){return this.stack[this.stack.length-1]},find_parent:function(type){var stack=this.stack;for(var i=stack.length;--i>=0;){var x=stack[i];if(x instanceof type)return x}},has_directive:function(type){return this.find_parent(AST_Scope).has_directive(type)},in_boolean_context:function(){var stack=this.stack;var i=stack.length,self=stack[--i];while(i>0){var p=stack[--i];if(p instanceof AST_If&&p.condition===self||p instanceof AST_Conditional&&p.condition===self||p instanceof AST_DWLoop&&p.condition===self||p instanceof AST_For&&p.condition===self||p instanceof AST_UnaryPrefix&&p.operator=="!"&&p.expression===self){return true}if(!(p instanceof AST_Binary&&(p.operator=="&&"||p.operator=="||")))return false;self=p}},loopcontrol_target:function(label){var stack=this.stack;if(label)for(var i=stack.length;--i>=0;){var x=stack[i];if(x instanceof AST_LabeledStatement&&x.label.name==label.name){return x.body}}else for(var i=stack.length;--i>=0;){var x=stack[i];if(x instanceof AST_Switch||x instanceof AST_IterationStatement)return x}}};/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+    Parser based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";var KEYWORDS="break case catch const continue debugger default delete do else finally for function if in instanceof new return switch throw try typeof var void while with";var KEYWORDS_ATOM="false null true";var RESERVED_WORDS="abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield"+" "+KEYWORDS_ATOM+" "+KEYWORDS;var KEYWORDS_BEFORE_EXPRESSION="return new delete throw else case";KEYWORDS=makePredicate(KEYWORDS);RESERVED_WORDS=makePredicate(RESERVED_WORDS);KEYWORDS_BEFORE_EXPRESSION=makePredicate(KEYWORDS_BEFORE_EXPRESSION);KEYWORDS_ATOM=makePredicate(KEYWORDS_ATOM);var OPERATOR_CHARS=makePredicate(characters("+-*&%=<>!?|~^"));var RE_HEX_NUMBER=/^0x[0-9a-f]+$/i;var RE_OCT_NUMBER=/^0[0-7]+$/;var RE_DEC_NUMBER=/^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;var OPERATORS=makePredicate(["in","instanceof","typeof","new","void","delete","++","--","+","-","!","~","&","|","^","*","/","%",">>","<<",">>>","<",">","<=",">=","==","===","!=","!==","?","=","+=","-=","/=","*=","%=",">>=","<<=",">>>=","|=","^=","&=","&&","||"]);var WHITESPACE_CHARS=makePredicate(characters("  \n\r	\f​᠎             　"));var PUNC_BEFORE_EXPRESSION=makePredicate(characters("[{(,.;:"));var PUNC_CHARS=makePredicate(characters("[]{}(),;:"));var REGEXP_MODIFIERS=makePredicate(characters("gmsiy"));var UNICODE={letter:new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),non_spacing_mark:new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),space_combining_mark:new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),connector_punctuation:new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")};function is_letter(code){return code>=97&&code<=122||code>=65&&code<=90||code>=170&&UNICODE.letter.test(String.fromCharCode(code))}function is_digit(code){return code>=48&&code<=57}function is_alphanumeric_char(code){return is_digit(code)||is_letter(code)}function is_unicode_combining_mark(ch){return UNICODE.non_spacing_mark.test(ch)||UNICODE.space_combining_mark.test(ch)}function is_unicode_connector_punctuation(ch){return UNICODE.connector_punctuation.test(ch)}function is_identifier(name){return!RESERVED_WORDS(name)&&/^[a-z_$][a-z0-9_$]*$/i.test(name)}function is_identifier_start(code){return code==36||code==95||is_letter(code)}function is_identifier_char(ch){var code=ch.charCodeAt(0);return is_identifier_start(code)||is_digit(code)||code==8204||code==8205||is_unicode_combining_mark(ch)||is_unicode_connector_punctuation(ch)}function is_identifier_string(str){return/^[a-z_$][a-z0-9_$]*$/i.test(str)}function parse_js_number(num){if(RE_HEX_NUMBER.test(num)){return parseInt(num.substr(2),16)}else if(RE_OCT_NUMBER.test(num)){return parseInt(num.substr(1),8)}else if(RE_DEC_NUMBER.test(num)){return parseFloat(num)}}function JS_Parse_Error(message,line,col,pos){this.message=message;this.line=line;this.col=col;this.pos=pos;this.stack=(new Error).stack}JS_Parse_Error.prototype.toString=function(){return this.message+" (line: "+this.line+", col: "+this.col+", pos: "+this.pos+")"+"\n\n"+this.stack};function js_error(message,filename,line,col,pos){throw new JS_Parse_Error(message,line,col,pos)}function is_token(token,type,val){return token.type==type&&(val==null||token.value==val)}var EX_EOF={};function tokenizer($TEXT,filename,html5_comments){var S={text:$TEXT.replace(/\r\n?|[\n\u2028\u2029]/g,"\n").replace(/\uFEFF/g,""),filename:filename,pos:0,tokpos:0,line:1,tokline:0,col:0,tokcol:0,newline_before:false,regex_allowed:false,comments_before:[]};function peek(){return S.text.charAt(S.pos)}function next(signal_eof,in_string){var ch=S.text.charAt(S.pos++);if(signal_eof&&!ch)throw EX_EOF;if(ch=="\n"){S.newline_before=S.newline_before||!in_string;++S.line;S.col=0}else{++S.col}return ch}function forward(i){while(i-->0)next()}function looking_at(str){return S.text.substr(S.pos,str.length)==str}function find(what,signal_eof){var pos=S.text.indexOf(what,S.pos);if(signal_eof&&pos==-1)throw EX_EOF;return pos}function start_token(){S.tokline=S.line;S.tokcol=S.col;S.tokpos=S.pos}var prev_was_dot=false;function token(type,value,is_comment){S.regex_allowed=type=="operator"&&!UNARY_POSTFIX(value)||type=="keyword"&&KEYWORDS_BEFORE_EXPRESSION(value)||type=="punc"&&PUNC_BEFORE_EXPRESSION(value);prev_was_dot=type=="punc"&&value==".";var ret={type:type,value:value,line:S.tokline,col:S.tokcol,pos:S.tokpos,endpos:S.pos,nlb:S.newline_before,file:filename};if(!is_comment){ret.comments_before=S.comments_before;S.comments_before=[];for(var i=0,len=ret.comments_before.length;i<len;i++){ret.nlb=ret.nlb||ret.comments_before[i].nlb}}S.newline_before=false;return new AST_Token(ret)}function skip_whitespace(){while(WHITESPACE_CHARS(peek()))next()}function read_while(pred){var ret="",ch,i=0;while((ch=peek())&&pred(ch,i++))ret+=next();return ret}function parse_error(err){js_error(err,filename,S.tokline,S.tokcol,S.tokpos)}function read_num(prefix){var has_e=false,after_e=false,has_x=false,has_dot=prefix==".";var num=read_while(function(ch,i){var code=ch.charCodeAt(0);switch(code){case 120:case 88:return has_x?false:has_x=true;case 101:case 69:return has_x?true:has_e?false:has_e=after_e=true;case 45:return after_e||i==0&&!prefix;case 43:return after_e;case after_e=false,46:return!has_dot&&!has_x&&!has_e?has_dot=true:false}return is_alphanumeric_char(code)});if(prefix)num=prefix+num;var valid=parse_js_number(num);if(!isNaN(valid)){return token("num",valid)}else{parse_error("Invalid syntax: "+num)}}function read_escaped_char(in_string){var ch=next(true,in_string);switch(ch.charCodeAt(0)){case 110:return"\n";case 114:return"\r";case 116:return"	";case 98:return"\b";case 118:return"";case 102:return"\f";case 48:return"\x00";case 120:return String.fromCharCode(hex_bytes(2));case 117:return String.fromCharCode(hex_bytes(4));case 10:return"";default:return ch}}function hex_bytes(n){var num=0;for(;n>0;--n){var digit=parseInt(next(true),16);if(isNaN(digit))parse_error("Invalid hex-character pattern in string");num=num<<4|digit}return num}var read_string=with_eof_error("Unterminated string constant",function(){var quote=next(),ret="";for(;;){var ch=next(true);if(ch=="\\"){var octal_len=0,first=null;ch=read_while(function(ch){if(ch>="0"&&ch<="7"){if(!first){first=ch;return++octal_len}else if(first<="3"&&octal_len<=2)return++octal_len;else if(first>="4"&&octal_len<=1)return++octal_len}return false});if(octal_len>0)ch=String.fromCharCode(parseInt(ch,8));else ch=read_escaped_char(true)}else if(ch==quote)break;ret+=ch}return token("string",ret)});function skip_line_comment(type){var regex_allowed=S.regex_allowed;var i=find("\n"),ret;if(i==-1){ret=S.text.substr(S.pos);S.pos=S.text.length}else{ret=S.text.substring(S.pos,i);S.pos=i}S.comments_before.push(token(type,ret,true));S.regex_allowed=regex_allowed;return next_token()}var skip_multiline_comment=with_eof_error("Unterminated multiline comment",function(){var regex_allowed=S.regex_allowed;var i=find("*/",true);var text=S.text.substring(S.pos,i);var a=text.split("\n"),n=a.length;S.pos=i+2;S.line+=n-1;if(n>1)S.col=a[n-1].length;else S.col+=a[n-1].length;S.col+=2;var nlb=S.newline_before=S.newline_before||text.indexOf("\n")>=0;S.comments_before.push(token("comment2",text,true));S.regex_allowed=regex_allowed;S.newline_before=nlb;return next_token()});function read_name(){var backslash=false,name="",ch,escaped=false,hex;while((ch=peek())!=null){if(!backslash){if(ch=="\\")escaped=backslash=true,next();else if(is_identifier_char(ch))name+=next();else break}else{if(ch!="u")parse_error("Expecting UnicodeEscapeSequence -- uXXXX");ch=read_escaped_char();if(!is_identifier_char(ch))parse_error("Unicode char: "+ch.charCodeAt(0)+" is not valid in identifier");name+=ch;backslash=false}}if(KEYWORDS(name)&&escaped){hex=name.charCodeAt(0).toString(16).toUpperCase();name="\\u"+"0000".substr(hex.length)+hex+name.slice(1)}return name}var read_regexp=with_eof_error("Unterminated regular expression",function(regexp){var prev_backslash=false,ch,in_class=false;while(ch=next(true))if(prev_backslash){regexp+="\\"+ch;prev_backslash=false}else if(ch=="["){in_class=true;regexp+=ch}else if(ch=="]"&&in_class){in_class=false;regexp+=ch}else if(ch=="/"&&!in_class){break}else if(ch=="\\"){prev_backslash=true}else{regexp+=ch}var mods=read_name();return token("regexp",new RegExp(regexp,mods))});function read_operator(prefix){function grow(op){if(!peek())return op;var bigger=op+peek();if(OPERATORS(bigger)){next();return grow(bigger)}else{return op}}return token("operator",grow(prefix||next()))}function handle_slash(){next();switch(peek()){case"/":next();return skip_line_comment("comment1");case"*":next();return skip_multiline_comment()}return S.regex_allowed?read_regexp(""):read_operator("/")}function handle_dot(){next();return is_digit(peek().charCodeAt(0))?read_num("."):token("punc",".")}function read_word(){var word=read_name();if(prev_was_dot)return token("name",word);return KEYWORDS_ATOM(word)?token("atom",word):!KEYWORDS(word)?token("name",word):OPERATORS(word)?token("operator",word):token("keyword",word)}function with_eof_error(eof_error,cont){return function(x){try{return cont(x)}catch(ex){if(ex===EX_EOF)parse_error(eof_error);else throw ex}}}function next_token(force_regexp){if(force_regexp!=null)return read_regexp(force_regexp);skip_whitespace();start_token();if(html5_comments){if(looking_at("<!--")){forward(4);return skip_line_comment("comment3")}if(looking_at("-->")&&S.newline_before){forward(3);return skip_line_comment("comment4")}}var ch=peek();if(!ch)return token("eof");var code=ch.charCodeAt(0);switch(code){case 34:case 39:return read_string();case 46:return handle_dot();case 47:return handle_slash()}if(is_digit(code))return read_num();if(PUNC_CHARS(ch))return token("punc",next());if(OPERATOR_CHARS(ch))return read_operator();if(code==92||is_identifier_start(code))return read_word();parse_error("Unexpected character '"+ch+"'")}next_token.context=function(nc){if(nc)S=nc;return S};return next_token}var UNARY_PREFIX=makePredicate(["typeof","void","delete","--","++","!","~","-","+"]);var UNARY_POSTFIX=makePredicate(["--","++"]);var ASSIGNMENT=makePredicate(["=","+=","-=","/=","*=","%=",">>=","<<=",">>>=","|=","^=","&="]);var PRECEDENCE=function(a,ret){for(var i=0;i<a.length;++i){var b=a[i];for(var j=0;j<b.length;++j){ret[b[j]]=i+1}}return ret}([["||"],["&&"],["|"],["^"],["&"],["==","===","!=","!=="],["<",">","<=",">=","in","instanceof"],[">>","<<",">>>"],["+","-"],["*","/","%"]],{});var STATEMENTS_WITH_LABELS=array_to_hash(["for","do","while","switch"]);var ATOMIC_START_TOKEN=array_to_hash(["atom","num","string","regexp","name"]);function parse($TEXT,options){options=defaults(options,{strict:false,filename:null,toplevel:null,expression:false,html5_comments:true,bare_returns:false});var S={input:typeof $TEXT=="string"?tokenizer($TEXT,options.filename,options.html5_comments):$TEXT,token:null,prev:null,peeked:null,in_function:0,in_directives:true,in_loop:0,labels:[]};S.token=next();function is(type,value){return is_token(S.token,type,value)}function peek(){return S.peeked||(S.peeked=S.input())}function next(){S.prev=S.token;if(S.peeked){S.token=S.peeked;S.peeked=null}else{S.token=S.input()}S.in_directives=S.in_directives&&(S.token.type=="string"||is("punc",";"));return S.token}function prev(){return S.prev}function croak(msg,line,col,pos){var ctx=S.input.context();js_error(msg,ctx.filename,line!=null?line:ctx.tokline,col!=null?col:ctx.tokcol,pos!=null?pos:ctx.tokpos)}function token_error(token,msg){croak(msg,token.line,token.col)}function unexpected(token){if(token==null)token=S.token;token_error(token,"Unexpected token: "+token.type+" ("+token.value+")")}function expect_token(type,val){if(is(type,val)){return next()}token_error(S.token,"Unexpected token "+S.token.type+" «"+S.token.value+"»"+", expected "+type+" «"+val+"»")}function expect(punc){return expect_token("punc",punc)}function can_insert_semicolon(){return!options.strict&&(S.token.nlb||is("eof")||is("punc","}"))}function semicolon(){if(is("punc",";"))next();else if(!can_insert_semicolon())unexpected()}function parenthesised(){expect("(");var exp=expression(true);expect(")");return exp}function embed_tokens(parser){return function(){var start=S.token;var expr=parser();var end=prev();expr.start=start;expr.end=end;return expr}}function handle_regexp(){if(is("operator","/")||is("operator","/=")){S.peeked=null;S.token=S.input(S.token.value.substr(1))}}var statement=embed_tokens(function(){var tmp;handle_regexp();switch(S.token.type){case"string":var dir=S.in_directives,stat=simple_statement();if(dir&&stat.body instanceof AST_String&&!is("punc",","))return new AST_Directive({value:stat.body.value});return stat;case"num":case"regexp":case"operator":case"atom":return simple_statement();case"name":return is_token(peek(),"punc",":")?labeled_statement():simple_statement();case"punc":switch(S.token.value){case"{":return new AST_BlockStatement({start:S.token,body:block_(),end:prev()});case"[":case"(":return simple_statement();case";":next();return new AST_EmptyStatement;default:unexpected()}case"keyword":switch(tmp=S.token.value,next(),tmp){case"break":return break_cont(AST_Break);case"continue":return break_cont(AST_Continue);case"debugger":semicolon();return new AST_Debugger;case"do":return new AST_Do({body:in_loop(statement),condition:(expect_token("keyword","while"),tmp=parenthesised(),semicolon(),tmp)});case"while":return new AST_While({condition:parenthesised(),body:in_loop(statement)});case"for":return for_();case"function":return function_(AST_Defun);case"if":return if_();case"return":if(S.in_function==0&&!options.bare_returns)croak("'return' outside of function");return new AST_Return({value:is("punc",";")?(next(),null):can_insert_semicolon()?null:(tmp=expression(true),semicolon(),tmp)});case"switch":return new AST_Switch({expression:parenthesised(),body:in_loop(switch_body_)});case"throw":if(S.token.nlb)croak("Illegal newline after 'throw'");return new AST_Throw({value:(tmp=expression(true),semicolon(),tmp)});case"try":return try_();case"var":return tmp=var_(),semicolon(),tmp;case"const":return tmp=const_(),semicolon(),tmp;case"with":return new AST_With({expression:parenthesised(),body:statement()});default:unexpected()}}});function labeled_statement(){var label=as_symbol(AST_Label);if(find_if(function(l){return l.name==label.name},S.labels)){croak("Label "+label.name+" defined twice")}expect(":");S.labels.push(label);var stat=statement();S.labels.pop();if(!(stat instanceof AST_IterationStatement)){label.references.forEach(function(ref){if(ref instanceof AST_Continue){ref=ref.label.start;croak("Continue label `"+label.name+"` refers to non-IterationStatement.",ref.line,ref.col,ref.pos)}})}return new AST_LabeledStatement({body:stat,label:label})}function simple_statement(tmp){return new AST_SimpleStatement({body:(tmp=expression(true),semicolon(),tmp)})}function break_cont(type){var label=null,ldef;if(!can_insert_semicolon()){label=as_symbol(AST_LabelRef,true)}if(label!=null){ldef=find_if(function(l){return l.name==label.name},S.labels);if(!ldef)croak("Undefined label "+label.name);label.thedef=ldef}else if(S.in_loop==0)croak(type.TYPE+" not inside a loop or switch");semicolon();var stat=new type({label:label});if(ldef)ldef.references.push(stat);return stat}function for_(){expect("(");var init=null;if(!is("punc",";")){init=is("keyword","var")?(next(),var_(true)):expression(true,true);if(is("operator","in")){if(init instanceof AST_Var&&init.definitions.length>1)croak("Only one variable declaration allowed in for..in loop");next();return for_in(init)}}return regular_for(init)}function regular_for(init){expect(";");var test=is("punc",";")?null:expression(true);expect(";");var step=is("punc",")")?null:expression(true);expect(")");return new AST_For({init:init,condition:test,step:step,body:in_loop(statement)})}function for_in(init){var lhs=init instanceof AST_Var?init.definitions[0].name:null;var obj=expression(true);expect(")");return new AST_ForIn({init:init,name:lhs,object:obj,body:in_loop(statement)})}var function_=function(ctor){var in_statement=ctor===AST_Defun;var name=is("name")?as_symbol(in_statement?AST_SymbolDefun:AST_SymbolLambda):null;if(in_statement&&!name)unexpected();expect("(");return new ctor({name:name,argnames:function(first,a){while(!is("punc",")")){if(first)first=false;else expect(",");a.push(as_symbol(AST_SymbolFunarg))}next();return a}(true,[]),body:function(loop,labels){++S.in_function;S.in_directives=true;S.in_loop=0;S.labels=[];var a=block_();--S.in_function;S.in_loop=loop;S.labels=labels;return a}(S.in_loop,S.labels)})};function if_(){var cond=parenthesised(),body=statement(),belse=null;if(is("keyword","else")){next();belse=statement()}return new AST_If({condition:cond,body:body,alternative:belse})}function block_(){expect("{");var a=[];while(!is("punc","}")){if(is("eof"))unexpected();a.push(statement())}next();return a}function switch_body_(){expect("{");var a=[],cur=null,branch=null,tmp;while(!is("punc","}")){if(is("eof"))unexpected();if(is("keyword","case")){if(branch)branch.end=prev();cur=[];branch=new AST_Case({start:(tmp=S.token,next(),tmp),expression:expression(true),body:cur});a.push(branch);expect(":")}else if(is("keyword","default")){if(branch)branch.end=prev();cur=[];branch=new AST_Default({start:(tmp=S.token,next(),expect(":"),tmp),body:cur});a.push(branch)}else{if(!cur)unexpected();cur.push(statement())}}if(branch)branch.end=prev();next();return a}function try_(){var body=block_(),bcatch=null,bfinally=null;if(is("keyword","catch")){var start=S.token;next();expect("(");var name=as_symbol(AST_SymbolCatch);expect(")");bcatch=new AST_Catch({start:start,argname:name,body:block_(),end:prev()})}if(is("keyword","finally")){var start=S.token;next();bfinally=new AST_Finally({start:start,body:block_(),end:prev()})}if(!bcatch&&!bfinally)croak("Missing catch/finally blocks");return new AST_Try({body:body,bcatch:bcatch,bfinally:bfinally})}function vardefs(no_in,in_const){var a=[];for(;;){a.push(new AST_VarDef({start:S.token,name:as_symbol(in_const?AST_SymbolConst:AST_SymbolVar),value:is("operator","=")?(next(),expression(false,no_in)):null,end:prev()}));if(!is("punc",","))break;next()}return a}var var_=function(no_in){return new AST_Var({start:prev(),definitions:vardefs(no_in,false),end:prev()})};var const_=function(){return new AST_Const({start:prev(),definitions:vardefs(false,true),end:prev()})};var new_=function(){var start=S.token;expect_token("operator","new");var newexp=expr_atom(false),args;if(is("punc","(")){next();args=expr_list(")")}else{args=[]}return subscripts(new AST_New({start:start,expression:newexp,args:args,end:prev()}),true)};function as_atom_node(){var tok=S.token,ret;switch(tok.type){case"name":case"keyword":ret=_make_symbol(AST_SymbolRef);break;case"num":ret=new AST_Number({start:tok,end:tok,value:tok.value});break;case"string":ret=new AST_String({start:tok,end:tok,value:tok.value});break;case"regexp":ret=new AST_RegExp({start:tok,end:tok,value:tok.value});break;case"atom":switch(tok.value){case"false":ret=new AST_False({start:tok,end:tok});break;case"true":ret=new AST_True({start:tok,end:tok});break;case"null":ret=new AST_Null({start:tok,end:tok});break}break}next();return ret}var expr_atom=function(allow_calls){if(is("operator","new")){return new_()}var start=S.token;if(is("punc")){switch(start.value){case"(":next();var ex=expression(true);ex.start=start;ex.end=S.token;expect(")");return subscripts(ex,allow_calls);case"[":return subscripts(array_(),allow_calls);case"{":return subscripts(object_(),allow_calls)}unexpected()}if(is("keyword","function")){next();var func=function_(AST_Function);func.start=start;func.end=prev();return subscripts(func,allow_calls)}if(ATOMIC_START_TOKEN[S.token.type]){return subscripts(as_atom_node(),allow_calls)}unexpected()};function expr_list(closing,allow_trailing_comma,allow_empty){var first=true,a=[];while(!is("punc",closing)){if(first)first=false;else expect(",");if(allow_trailing_comma&&is("punc",closing))break;if(is("punc",",")&&allow_empty){a.push(new AST_Hole({start:S.token,end:S.token}))}else{a.push(expression(false))}}next();return a}var array_=embed_tokens(function(){expect("[");return new AST_Array({elements:expr_list("]",!options.strict,true)})});var object_=embed_tokens(function(){expect("{");var first=true,a=[];while(!is("punc","}")){if(first)first=false;else expect(",");if(!options.strict&&is("punc","}"))break;var start=S.token;var type=start.type;var name=as_property_name();if(type=="name"&&!is("punc",":")){if(name=="get"){a.push(new AST_ObjectGetter({start:start,key:as_atom_node(),value:function_(AST_Accessor),end:prev()}));continue}if(name=="set"){a.push(new AST_ObjectSetter({start:start,key:as_atom_node(),value:function_(AST_Accessor),end:prev()}));continue}}expect(":");a.push(new AST_ObjectKeyVal({start:start,key:name,value:expression(false),end:prev()}))}next();return new AST_Object({properties:a})});function as_property_name(){var tmp=S.token;next();switch(tmp.type){case"num":case"string":case"name":case"operator":case"keyword":case"atom":return tmp.value;default:unexpected()}}function as_name(){var tmp=S.token;next();switch(tmp.type){case"name":case"operator":case"keyword":case"atom":return tmp.value;default:unexpected()}}function _make_symbol(type){var name=S.token.value;return new(name=="this"?AST_This:type)({name:String(name),start:S.token,end:S.token})}function as_symbol(type,noerror){if(!is("name")){if(!noerror)croak("Name expected");return null}var sym=_make_symbol(type);next();return sym}var subscripts=function(expr,allow_calls){var start=expr.start;if(is("punc",".")){next();return subscripts(new AST_Dot({start:start,expression:expr,property:as_name(),end:prev()}),allow_calls)}if(is("punc","[")){next();var prop=expression(true);expect("]");return subscripts(new AST_Sub({start:start,expression:expr,property:prop,end:prev()}),allow_calls)}if(allow_calls&&is("punc","(")){next();return subscripts(new AST_Call({start:start,expression:expr,args:expr_list(")"),end:prev()}),true)}return expr};var maybe_unary=function(allow_calls){var start=S.token;if(is("operator")&&UNARY_PREFIX(start.value)){next();handle_regexp();var ex=make_unary(AST_UnaryPrefix,start.value,maybe_unary(allow_calls));ex.start=start;ex.end=prev();return ex}var val=expr_atom(allow_calls);while(is("operator")&&UNARY_POSTFIX(S.token.value)&&!S.token.nlb){val=make_unary(AST_UnaryPostfix,S.token.value,val);val.start=start;val.end=S.token;next()}return val};function make_unary(ctor,op,expr){if((op=="++"||op=="--")&&!is_assignable(expr))croak("Invalid use of "+op+" operator");return new ctor({operator:op,expression:expr})}var expr_op=function(left,min_prec,no_in){var op=is("operator")?S.token.value:null;if(op=="in"&&no_in)op=null;var prec=op!=null?PRECEDENCE[op]:null;if(prec!=null&&prec>min_prec){next();var right=expr_op(maybe_unary(true),prec,no_in);return expr_op(new AST_Binary({start:left.start,left:left,operator:op,right:right,end:right.end}),min_prec,no_in)}return left};function expr_ops(no_in){return expr_op(maybe_unary(true),0,no_in)}var maybe_conditional=function(no_in){var start=S.token;var expr=expr_ops(no_in);if(is("operator","?")){next();var yes=expression(false);expect(":");return new AST_Conditional({start:start,condition:expr,consequent:yes,alternative:expression(false,no_in),end:prev()})}return expr};function is_assignable(expr){if(!options.strict)return true;if(expr instanceof AST_This)return false;return expr instanceof AST_PropAccess||expr instanceof AST_Symbol}var maybe_assign=function(no_in){var start=S.token;var left=maybe_conditional(no_in),val=S.token.value;if(is("operator")&&ASSIGNMENT(val)){if(is_assignable(left)){next();return new AST_Assign({start:start,left:left,operator:val,right:maybe_assign(no_in),end:prev()})}croak("Invalid assignment")}return left};var expression=function(commas,no_in){var start=S.token;var expr=maybe_assign(no_in);if(commas&&is("punc",",")){next();return new AST_Seq({start:start,car:expr,cdr:expression(true,no_in),end:peek()})}return expr};function in_loop(cont){++S.in_loop;var ret=cont();--S.in_loop;return ret}if(options.expression){return expression(true)}return function(){var start=S.token;var body=[];while(!is("eof"))body.push(statement());var end=prev();var toplevel=options.toplevel;
+if(toplevel){toplevel.body=toplevel.body.concat(body);toplevel.end=end}else{toplevel=new AST_Toplevel({start:start,body:body,end:end})}return toplevel}()}/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function TreeTransformer(before,after){TreeWalker.call(this);this.before=before;this.after=after}TreeTransformer.prototype=new TreeWalker;(function(undefined){function _(node,descend){node.DEFMETHOD("transform",function(tw,in_list){var x,y;tw.push(this);if(tw.before)x=tw.before(this,descend,in_list);if(x===undefined){if(!tw.after){x=this;descend(x,tw)}else{tw.stack[tw.stack.length-1]=x=this.clone();descend(x,tw);y=tw.after(x,in_list);if(y!==undefined)x=y}}tw.pop();return x})}function do_list(list,tw){return MAP(list,function(node){return node.transform(tw,true)})}_(AST_Node,noop);_(AST_LabeledStatement,function(self,tw){self.label=self.label.transform(tw);self.body=self.body.transform(tw)});_(AST_SimpleStatement,function(self,tw){self.body=self.body.transform(tw)});_(AST_Block,function(self,tw){self.body=do_list(self.body,tw)});_(AST_DWLoop,function(self,tw){self.condition=self.condition.transform(tw);self.body=self.body.transform(tw)});_(AST_For,function(self,tw){if(self.init)self.init=self.init.transform(tw);if(self.condition)self.condition=self.condition.transform(tw);if(self.step)self.step=self.step.transform(tw);self.body=self.body.transform(tw)});_(AST_ForIn,function(self,tw){self.init=self.init.transform(tw);self.object=self.object.transform(tw);self.body=self.body.transform(tw)});_(AST_With,function(self,tw){self.expression=self.expression.transform(tw);self.body=self.body.transform(tw)});_(AST_Exit,function(self,tw){if(self.value)self.value=self.value.transform(tw)});_(AST_LoopControl,function(self,tw){if(self.label)self.label=self.label.transform(tw)});_(AST_If,function(self,tw){self.condition=self.condition.transform(tw);self.body=self.body.transform(tw);if(self.alternative)self.alternative=self.alternative.transform(tw)});_(AST_Switch,function(self,tw){self.expression=self.expression.transform(tw);self.body=do_list(self.body,tw)});_(AST_Case,function(self,tw){self.expression=self.expression.transform(tw);self.body=do_list(self.body,tw)});_(AST_Try,function(self,tw){self.body=do_list(self.body,tw);if(self.bcatch)self.bcatch=self.bcatch.transform(tw);if(self.bfinally)self.bfinally=self.bfinally.transform(tw)});_(AST_Catch,function(self,tw){self.argname=self.argname.transform(tw);self.body=do_list(self.body,tw)});_(AST_Definitions,function(self,tw){self.definitions=do_list(self.definitions,tw)});_(AST_VarDef,function(self,tw){self.name=self.name.transform(tw);if(self.value)self.value=self.value.transform(tw)});_(AST_Lambda,function(self,tw){if(self.name)self.name=self.name.transform(tw);self.argnames=do_list(self.argnames,tw);self.body=do_list(self.body,tw)});_(AST_Call,function(self,tw){self.expression=self.expression.transform(tw);self.args=do_list(self.args,tw)});_(AST_Seq,function(self,tw){self.car=self.car.transform(tw);self.cdr=self.cdr.transform(tw)});_(AST_Dot,function(self,tw){self.expression=self.expression.transform(tw)});_(AST_Sub,function(self,tw){self.expression=self.expression.transform(tw);self.property=self.property.transform(tw)});_(AST_Unary,function(self,tw){self.expression=self.expression.transform(tw)});_(AST_Binary,function(self,tw){self.left=self.left.transform(tw);self.right=self.right.transform(tw)});_(AST_Conditional,function(self,tw){self.condition=self.condition.transform(tw);self.consequent=self.consequent.transform(tw);self.alternative=self.alternative.transform(tw)});_(AST_Array,function(self,tw){self.elements=do_list(self.elements,tw)});_(AST_Object,function(self,tw){self.properties=do_list(self.properties,tw)});_(AST_ObjectProperty,function(self,tw){self.value=self.value.transform(tw)})})();/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function SymbolDef(scope,index,orig){this.name=orig.name;this.orig=[orig];this.scope=scope;this.references=[];this.global=false;this.mangled_name=null;this.undeclared=false;this.constant=false;this.index=index}SymbolDef.prototype={unmangleable:function(options){return this.global&&!(options&&options.toplevel)||this.undeclared||!(options&&options.eval)&&(this.scope.uses_eval||this.scope.uses_with)},mangle:function(options){if(!this.mangled_name&&!this.unmangleable(options)){var s=this.scope;if(!options.screw_ie8&&this.orig[0]instanceof AST_SymbolLambda)s=s.parent_scope;this.mangled_name=s.next_mangled(options,this)}}};AST_Toplevel.DEFMETHOD("figure_out_scope",function(options){options=defaults(options,{screw_ie8:false});var self=this;var scope=self.parent_scope=null;var defun=null;var nesting=0;var tw=new TreeWalker(function(node,descend){if(options.screw_ie8&&node instanceof AST_Catch){var save_scope=scope;scope=new AST_Scope(node);scope.init_scope_vars(nesting);scope.parent_scope=save_scope;descend();scope=save_scope;return true}if(node instanceof AST_Scope){node.init_scope_vars(nesting);var save_scope=node.parent_scope=scope;var save_defun=defun;defun=scope=node;++nesting;descend();--nesting;scope=save_scope;defun=save_defun;return true}if(node instanceof AST_Directive){node.scope=scope;push_uniq(scope.directives,node.value);return true}if(node instanceof AST_With){for(var s=scope;s;s=s.parent_scope)s.uses_with=true;return}if(node instanceof AST_Symbol){node.scope=scope}if(node instanceof AST_SymbolLambda){defun.def_function(node)}else if(node instanceof AST_SymbolDefun){(node.scope=defun.parent_scope).def_function(node)}else if(node instanceof AST_SymbolVar||node instanceof AST_SymbolConst){var def=defun.def_variable(node);def.constant=node instanceof AST_SymbolConst;def.init=tw.parent().value}else if(node instanceof AST_SymbolCatch){(options.screw_ie8?scope:defun).def_variable(node)}});self.walk(tw);var func=null;var globals=self.globals=new Dictionary;var tw=new TreeWalker(function(node,descend){if(node instanceof AST_Lambda){var prev_func=func;func=node;descend();func=prev_func;return true}if(node instanceof AST_SymbolRef){var name=node.name;var sym=node.scope.find_variable(name);if(!sym){var g;if(globals.has(name)){g=globals.get(name)}else{g=new SymbolDef(self,globals.size(),node);g.undeclared=true;g.global=true;globals.set(name,g)}node.thedef=g;if(name=="eval"&&tw.parent()instanceof AST_Call){for(var s=node.scope;s&&!s.uses_eval;s=s.parent_scope)s.uses_eval=true}if(func&&name=="arguments"){func.uses_arguments=true}}else{node.thedef=sym}node.reference();return true}});self.walk(tw)});AST_Scope.DEFMETHOD("init_scope_vars",function(nesting){this.directives=[];this.variables=new Dictionary;this.functions=new Dictionary;this.uses_with=false;this.uses_eval=false;this.parent_scope=null;this.enclosed=[];this.cname=-1;this.nesting=nesting});AST_Scope.DEFMETHOD("strict",function(){return this.has_directive("use strict")});AST_Lambda.DEFMETHOD("init_scope_vars",function(){AST_Scope.prototype.init_scope_vars.apply(this,arguments);this.uses_arguments=false});AST_SymbolRef.DEFMETHOD("reference",function(){var def=this.definition();def.references.push(this);var s=this.scope;while(s){push_uniq(s.enclosed,def);if(s===def.scope)break;s=s.parent_scope}this.frame=this.scope.nesting-def.scope.nesting});AST_Scope.DEFMETHOD("find_variable",function(name){if(name instanceof AST_Symbol)name=name.name;return this.variables.get(name)||this.parent_scope&&this.parent_scope.find_variable(name)});AST_Scope.DEFMETHOD("has_directive",function(value){return this.parent_scope&&this.parent_scope.has_directive(value)||(this.directives.indexOf(value)>=0?this:null)});AST_Scope.DEFMETHOD("def_function",function(symbol){this.functions.set(symbol.name,this.def_variable(symbol))});AST_Scope.DEFMETHOD("def_variable",function(symbol){var def;if(!this.variables.has(symbol.name)){def=new SymbolDef(this,this.variables.size(),symbol);this.variables.set(symbol.name,def);def.global=!this.parent_scope}else{def=this.variables.get(symbol.name);def.orig.push(symbol)}return symbol.thedef=def});AST_Scope.DEFMETHOD("next_mangled",function(options){var ext=this.enclosed;out:while(true){var m=base54(++this.cname);if(!is_identifier(m))continue;if(options.except.indexOf(m)>=0)continue;for(var i=ext.length;--i>=0;){var sym=ext[i];var name=sym.mangled_name||sym.unmangleable(options)&&sym.name;if(m==name)continue out}return m}});AST_Function.DEFMETHOD("next_mangled",function(options,def){var tricky_def=def.orig[0]instanceof AST_SymbolFunarg&&this.name&&this.name.definition();while(true){var name=AST_Lambda.prototype.next_mangled.call(this,options,def);if(!(tricky_def&&tricky_def.mangled_name==name))return name}});AST_Scope.DEFMETHOD("references",function(sym){if(sym instanceof AST_Symbol)sym=sym.definition();return this.enclosed.indexOf(sym)<0?null:sym});AST_Symbol.DEFMETHOD("unmangleable",function(options){return this.definition().unmangleable(options)});AST_SymbolAccessor.DEFMETHOD("unmangleable",function(){return true});AST_Label.DEFMETHOD("unmangleable",function(){return false});AST_Symbol.DEFMETHOD("unreferenced",function(){return this.definition().references.length==0&&!(this.scope.uses_eval||this.scope.uses_with)});AST_Symbol.DEFMETHOD("undeclared",function(){return this.definition().undeclared});AST_LabelRef.DEFMETHOD("undeclared",function(){return false});AST_Label.DEFMETHOD("undeclared",function(){return false});AST_Symbol.DEFMETHOD("definition",function(){return this.thedef});AST_Symbol.DEFMETHOD("global",function(){return this.definition().global});AST_Toplevel.DEFMETHOD("_default_mangler_options",function(options){return defaults(options,{except:[],eval:false,sort:false,toplevel:false,screw_ie8:false})});AST_Toplevel.DEFMETHOD("mangle_names",function(options){options=this._default_mangler_options(options);var lname=-1;var to_mangle=[];var tw=new TreeWalker(function(node,descend){if(node instanceof AST_LabeledStatement){var save_nesting=lname;descend();lname=save_nesting;return true}if(node instanceof AST_Scope){var p=tw.parent(),a=[];node.variables.each(function(symbol){if(options.except.indexOf(symbol.name)<0){a.push(symbol)}});if(options.sort)a.sort(function(a,b){return b.references.length-a.references.length});to_mangle.push.apply(to_mangle,a);return}if(node instanceof AST_Label){var name;do name=base54(++lname);while(!is_identifier(name));node.mangled_name=name;return true}if(options.screw_ie8&&node instanceof AST_SymbolCatch){to_mangle.push(node.definition());return}});this.walk(tw);to_mangle.forEach(function(def){def.mangle(options)})});AST_Toplevel.DEFMETHOD("compute_char_frequency",function(options){options=this._default_mangler_options(options);var tw=new TreeWalker(function(node){if(node instanceof AST_Constant)base54.consider(node.print_to_string());else if(node instanceof AST_Return)base54.consider("return");else if(node instanceof AST_Throw)base54.consider("throw");else if(node instanceof AST_Continue)base54.consider("continue");else if(node instanceof AST_Break)base54.consider("break");else if(node instanceof AST_Debugger)base54.consider("debugger");else if(node instanceof AST_Directive)base54.consider(node.value);else if(node instanceof AST_While)base54.consider("while");else if(node instanceof AST_Do)base54.consider("do while");else if(node instanceof AST_If){base54.consider("if");if(node.alternative)base54.consider("else")}else if(node instanceof AST_Var)base54.consider("var");else if(node instanceof AST_Const)base54.consider("const");else if(node instanceof AST_Lambda)base54.consider("function");else if(node instanceof AST_For)base54.consider("for");else if(node instanceof AST_ForIn)base54.consider("for in");else if(node instanceof AST_Switch)base54.consider("switch");else if(node instanceof AST_Case)base54.consider("case");else if(node instanceof AST_Default)base54.consider("default");else if(node instanceof AST_With)base54.consider("with");else if(node instanceof AST_ObjectSetter)base54.consider("set"+node.key);else if(node instanceof AST_ObjectGetter)base54.consider("get"+node.key);else if(node instanceof AST_ObjectKeyVal)base54.consider(node.key);else if(node instanceof AST_New)base54.consider("new");else if(node instanceof AST_This)base54.consider("this");else if(node instanceof AST_Try)base54.consider("try");else if(node instanceof AST_Catch)base54.consider("catch");else if(node instanceof AST_Finally)base54.consider("finally");else if(node instanceof AST_Symbol&&node.unmangleable(options))base54.consider(node.name);else if(node instanceof AST_Unary||node instanceof AST_Binary)base54.consider(node.operator);else if(node instanceof AST_Dot)base54.consider(node.property)});this.walk(tw);base54.sort()});var base54=function(){var string="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";var chars,frequency;function reset(){frequency=Object.create(null);chars=string.split("").map(function(ch){return ch.charCodeAt(0)});chars.forEach(function(ch){frequency[ch]=0})}base54.consider=function(str){for(var i=str.length;--i>=0;){var code=str.charCodeAt(i);if(code in frequency)++frequency[code]}};base54.sort=function(){chars=mergeSort(chars,function(a,b){if(is_digit(a)&&!is_digit(b))return 1;if(is_digit(b)&&!is_digit(a))return-1;return frequency[b]-frequency[a]})};base54.reset=reset;reset();base54.get=function(){return chars};base54.freq=function(){return frequency};function base54(num){var ret="",base=54;do{ret+=String.fromCharCode(chars[num%base]);num=Math.floor(num/base);base=64}while(num>0);return ret}return base54}();AST_Toplevel.DEFMETHOD("scope_warnings",function(options){options=defaults(options,{undeclared:false,unreferenced:true,assign_to_global:true,func_arguments:true,nested_defuns:true,eval:true});var tw=new TreeWalker(function(node){if(options.undeclared&&node instanceof AST_SymbolRef&&node.undeclared()){AST_Node.warn("Undeclared symbol: {name} [{file}:{line},{col}]",{name:node.name,file:node.start.file,line:node.start.line,col:node.start.col})}if(options.assign_to_global){var sym=null;if(node instanceof AST_Assign&&node.left instanceof AST_SymbolRef)sym=node.left;else if(node instanceof AST_ForIn&&node.init instanceof AST_SymbolRef)sym=node.init;if(sym&&(sym.undeclared()||sym.global()&&sym.scope!==sym.definition().scope)){AST_Node.warn("{msg}: {name} [{file}:{line},{col}]",{msg:sym.undeclared()?"Accidental global?":"Assignment to global",name:sym.name,file:sym.start.file,line:sym.start.line,col:sym.start.col})}}if(options.eval&&node instanceof AST_SymbolRef&&node.undeclared()&&node.name=="eval"){AST_Node.warn("Eval is used [{file}:{line},{col}]",node.start)}if(options.unreferenced&&(node instanceof AST_SymbolDeclaration||node instanceof AST_Label)&&!(node instanceof AST_SymbolCatch)&&node.unreferenced()){AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]",{type:node instanceof AST_Label?"Label":"Symbol",name:node.name,file:node.start.file,line:node.start.line,col:node.start.col})}if(options.func_arguments&&node instanceof AST_Lambda&&node.uses_arguments){AST_Node.warn("arguments used in function {name} [{file}:{line},{col}]",{name:node.name?node.name.name:"anonymous",file:node.start.file,line:node.start.line,col:node.start.col})}if(options.nested_defuns&&node instanceof AST_Defun&&!(tw.parent()instanceof AST_Scope)){AST_Node.warn('Function {name} declared in nested statement "{type}" [{file}:{line},{col}]',{name:node.name.name,type:tw.parent().TYPE,file:node.start.file,line:node.start.line,col:node.start.col})}});this.walk(tw)});/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function OutputStream(options){options=defaults(options,{indent_start:0,indent_level:4,quote_keys:false,space_colon:true,ascii_only:false,unescape_regexps:false,inline_script:false,width:80,max_line_len:32e3,beautify:false,source_map:null,bracketize:false,semicolons:true,comments:false,preserve_line:false,screw_ie8:false,preamble:null},true);var indentation=0;var current_col=0;var current_line=1;var current_pos=0;var OUTPUT="";function to_ascii(str,identifier){return str.replace(/[\u0080-\uffff]/g,function(ch){var code=ch.charCodeAt(0).toString(16);if(code.length<=2&&!identifier){while(code.length<2)code="0"+code;return"\\x"+code}else{while(code.length<4)code="0"+code;return"\\u"+code}})}function make_string(str){var dq=0,sq=0;str=str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029\0]/g,function(s){switch(s){case"\\":return"\\\\";case"\b":return"\\b";case"\f":return"\\f";case"\n":return"\\n";case"\r":return"\\r";case"\u2028":return"\\u2028";case"\u2029":return"\\u2029";case'"':++dq;return'"';case"'":++sq;return"'";case"\x00":return"\\x00"}return s});if(options.ascii_only)str=to_ascii(str);if(dq>sq)return"'"+str.replace(/\x27/g,"\\'")+"'";else return'"'+str.replace(/\x22/g,'\\"')+'"'}function encode_string(str){var ret=make_string(str);if(options.inline_script)ret=ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi,"<\\/script$1");return ret}function make_name(name){name=name.toString();if(options.ascii_only)name=to_ascii(name,true);return name}function make_indent(back){return repeat_string(" ",options.indent_start+indentation-back*options.indent_level)}var might_need_space=false;var might_need_semicolon=false;var last=null;function last_char(){return last.charAt(last.length-1)}function maybe_newline(){if(options.max_line_len&&current_col>options.max_line_len)print("\n")}var requireSemicolonChars=makePredicate("( [ + * / - , .");function print(str){str=String(str);var ch=str.charAt(0);if(might_need_semicolon){if((!ch||";}".indexOf(ch)<0)&&!/[;]$/.test(last)){if(options.semicolons||requireSemicolonChars(ch)){OUTPUT+=";";current_col++;current_pos++}else{OUTPUT+="\n";current_pos++;current_line++;current_col=0}if(!options.beautify)might_need_space=false}might_need_semicolon=false;maybe_newline()}if(!options.beautify&&options.preserve_line&&stack[stack.length-1]){var target_line=stack[stack.length-1].start.line;while(current_line<target_line){OUTPUT+="\n";current_pos++;current_line++;current_col=0;might_need_space=false}}if(might_need_space){var prev=last_char();if(is_identifier_char(prev)&&(is_identifier_char(ch)||ch=="\\")||/^[\+\-\/]$/.test(ch)&&ch==prev){OUTPUT+=" ";current_col++;current_pos++}might_need_space=false}var a=str.split(/\r?\n/),n=a.length-1;current_line+=n;if(n==0){current_col+=a[n].length}else{current_col=a[n].length}current_pos+=str.length;last=str;OUTPUT+=str}var space=options.beautify?function(){print(" ")}:function(){might_need_space=true};var indent=options.beautify?function(half){if(options.beautify){print(make_indent(half?.5:0))}}:noop;var with_indent=options.beautify?function(col,cont){if(col===true)col=next_indent();var save_indentation=indentation;indentation=col;var ret=cont();indentation=save_indentation;return ret}:function(col,cont){return cont()};var newline=options.beautify?function(){print("\n")}:noop;var semicolon=options.beautify?function(){print(";")}:function(){might_need_semicolon=true};function force_semicolon(){might_need_semicolon=false;print(";")}function next_indent(){return indentation+options.indent_level}function with_block(cont){var ret;print("{");newline();with_indent(next_indent(),function(){ret=cont()});indent();print("}");return ret}function with_parens(cont){print("(");var ret=cont();print(")");return ret}function with_square(cont){print("[");var ret=cont();print("]");return ret}function comma(){print(",");space()}function colon(){print(":");if(options.space_colon)space()}var add_mapping=options.source_map?function(token,name){try{if(token)options.source_map.add(token.file||"?",current_line,current_col,token.line,token.col,!name&&token.type=="name"?token.value:name)}catch(ex){AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]",{file:token.file,line:token.line,col:token.col,cline:current_line,ccol:current_col,name:name||""})}}:noop;function get(){return OUTPUT}if(options.preamble){print(options.preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g,"\n"))}var stack=[];return{get:get,toString:get,indent:indent,indentation:function(){return indentation},current_width:function(){return current_col-indentation},should_break:function(){return options.width&&this.current_width()>=options.width},newline:newline,print:print,space:space,comma:comma,colon:colon,last:function(){return last},semicolon:semicolon,force_semicolon:force_semicolon,to_ascii:to_ascii,print_name:function(name){print(make_name(name))},print_string:function(str){print(encode_string(str))},next_indent:next_indent,with_indent:with_indent,with_block:with_block,with_parens:with_parens,with_square:with_square,add_mapping:add_mapping,option:function(opt){return options[opt]},line:function(){return current_line},col:function(){return current_col},pos:function(){return current_pos},push_node:function(node){stack.push(node)},pop_node:function(){return stack.pop()},stack:function(){return stack},parent:function(n){return stack[stack.length-2-(n||0)]}}}(function(){function DEFPRINT(nodetype,generator){nodetype.DEFMETHOD("_codegen",generator)}AST_Node.DEFMETHOD("print",function(stream,force_parens){var self=this,generator=self._codegen;function doit(){self.add_comments(stream);self.add_source_map(stream);generator(self,stream)}stream.push_node(self);if(force_parens||self.needs_parens(stream)){stream.with_parens(doit)}else{doit()}stream.pop_node()});AST_Node.DEFMETHOD("print_to_string",function(options){var s=OutputStream(options);this.print(s);return s.get()});AST_Node.DEFMETHOD("add_comments",function(output){var c=output.option("comments"),self=this;if(c){var start=self.start;if(start&&!start._comments_dumped){start._comments_dumped=true;var comments=start.comments_before||[];if(self instanceof AST_Exit&&self.value){self.value.walk(new TreeWalker(function(node){if(node.start&&node.start.comments_before){comments=comments.concat(node.start.comments_before);node.start.comments_before=[]}if(node instanceof AST_Function||node instanceof AST_Array||node instanceof AST_Object){return true}}))}if(c.test){comments=comments.filter(function(comment){return c.test(comment.value)})}else if(typeof c=="function"){comments=comments.filter(function(comment){return c(self,comment)})}comments.forEach(function(c){if(/comment[134]/.test(c.type)){output.print("//"+c.value+"\n");output.indent()}else if(c.type=="comment2"){output.print("/*"+c.value+"*/");if(start.nlb){output.print("\n");output.indent()}else{output.space()}}})}}});function PARENS(nodetype,func){if(Array.isArray(nodetype)){nodetype.forEach(function(nodetype){PARENS(nodetype,func)})}else{nodetype.DEFMETHOD("needs_parens",func)}}PARENS(AST_Node,function(){return false});PARENS(AST_Function,function(output){return first_in_statement(output)});PARENS(AST_Object,function(output){return first_in_statement(output)});PARENS([AST_Unary,AST_Undefined],function(output){var p=output.parent();return p instanceof AST_PropAccess&&p.expression===this});PARENS(AST_Seq,function(output){var p=output.parent();return p instanceof AST_Call||p instanceof AST_Unary||p instanceof AST_Binary||p instanceof AST_VarDef||p instanceof AST_PropAccess||p instanceof AST_Array||p instanceof AST_ObjectProperty||p instanceof AST_Conditional});PARENS(AST_Binary,function(output){var p=output.parent();if(p instanceof AST_Call&&p.expression===this)return true;if(p instanceof AST_Unary)return true;if(p instanceof AST_PropAccess&&p.expression===this)return true;if(p instanceof AST_Binary){var po=p.operator,pp=PRECEDENCE[po];var so=this.operator,sp=PRECEDENCE[so];if(pp>sp||pp==sp&&this===p.right){return true}}});PARENS(AST_PropAccess,function(output){var p=output.parent();if(p instanceof AST_New&&p.expression===this){try{this.walk(new TreeWalker(function(node){if(node instanceof AST_Call)throw p}))}catch(ex){if(ex!==p)throw ex;return true}}});PARENS(AST_Call,function(output){var p=output.parent(),p1;if(p instanceof AST_New&&p.expression===this)return true;return this.expression instanceof AST_Function&&p instanceof AST_PropAccess&&p.expression===this&&(p1=output.parent(1))instanceof AST_Assign&&p1.left===p});PARENS(AST_New,function(output){var p=output.parent();if(no_constructor_parens(this,output)&&(p instanceof AST_PropAccess||p instanceof AST_Call&&p.expression===this))return true});PARENS(AST_Number,function(output){var p=output.parent();if(this.getValue()<0&&p instanceof AST_PropAccess&&p.expression===this)return true});PARENS(AST_NaN,function(output){var p=output.parent();if(p instanceof AST_PropAccess&&p.expression===this)return true});PARENS([AST_Assign,AST_Conditional],function(output){var p=output.parent();if(p instanceof AST_Unary)return true;if(p instanceof AST_Binary&&!(p instanceof AST_Assign))return true;if(p instanceof AST_Call&&p.expression===this)return true;if(p instanceof AST_Conditional&&p.condition===this)return true;if(p instanceof AST_PropAccess&&p.expression===this)return true});DEFPRINT(AST_Directive,function(self,output){output.print_string(self.value);output.semicolon()});DEFPRINT(AST_Debugger,function(self,output){output.print("debugger");output.semicolon()});function display_body(body,is_toplevel,output){var last=body.length-1;body.forEach(function(stmt,i){if(!(stmt instanceof AST_EmptyStatement)){output.indent();stmt.print(output);if(!(i==last&&is_toplevel)){output.newline();if(is_toplevel)output.newline()}}})}AST_StatementWithBody.DEFMETHOD("_do_print_body",function(output){force_statement(this.body,output)});DEFPRINT(AST_Statement,function(self,output){self.body.print(output);output.semicolon()});DEFPRINT(AST_Toplevel,function(self,output){display_body(self.body,true,output);output.print("")});DEFPRINT(AST_LabeledStatement,function(self,output){self.label.print(output);output.colon();self.body.print(output)});DEFPRINT(AST_SimpleStatement,function(self,output){self.body.print(output);output.semicolon()});function print_bracketed(body,output){if(body.length>0)output.with_block(function(){display_body(body,false,output)});else output.print("{}")}DEFPRINT(AST_BlockStatement,function(self,output){print_bracketed(self.body,output)});DEFPRINT(AST_EmptyStatement,function(self,output){output.semicolon()});DEFPRINT(AST_Do,function(self,output){output.print("do");output.space();self._do_print_body(output);output.space();output.print("while");output.space();output.with_parens(function(){self.condition.print(output)});output.semicolon()});DEFPRINT(AST_While,function(self,output){output.print("while");output.space();output.with_parens(function(){self.condition.print(output)});output.space();self._do_print_body(output)});DEFPRINT(AST_For,function(self,output){output.print("for");output.space();output.with_parens(function(){if(self.init&&!(self.init instanceof AST_EmptyStatement)){if(self.init instanceof AST_Definitions){self.init.print(output)}else{parenthesize_for_noin(self.init,output,true)}output.print(";");output.space()}else{output.print(";")}if(self.condition){self.condition.print(output);output.print(";");output.space()}else{output.print(";")}if(self.step){self.step.print(output)}});output.space();self._do_print_body(output)});DEFPRINT(AST_ForIn,function(self,output){output.print("for");output.space();output.with_parens(function(){self.init.print(output);output.space();output.print("in");output.space();self.object.print(output)});output.space();self._do_print_body(output)});DEFPRINT(AST_With,function(self,output){output.print("with");output.space();output.with_parens(function(){self.expression.print(output)});output.space();self._do_print_body(output)});AST_Lambda.DEFMETHOD("_do_print",function(output,nokeyword){var self=this;if(!nokeyword){output.print("function")}if(self.name){output.space();self.name.print(output)}output.with_parens(function(){self.argnames.forEach(function(arg,i){if(i)output.comma();arg.print(output)})});output.space();print_bracketed(self.body,output)});DEFPRINT(AST_Lambda,function(self,output){self._do_print(output)});AST_Exit.DEFMETHOD("_do_print",function(output,kind){output.print(kind);if(this.value){output.space();this.value.print(output)}output.semicolon()});DEFPRINT(AST_Return,function(self,output){self._do_print(output,"return")});DEFPRINT(AST_Throw,function(self,output){self._do_print(output,"throw")});AST_LoopControl.DEFMETHOD("_do_print",function(output,kind){output.print(kind);if(this.label){output.space();this.label.print(output)}output.semicolon()});DEFPRINT(AST_Break,function(self,output){self._do_print(output,"break")});DEFPRINT(AST_Continue,function(self,output){self._do_print(output,"continue")});function make_then(self,output){if(output.option("bracketize")){make_block(self.body,output);return}if(!self.body)return output.force_semicolon();if(self.body instanceof AST_Do&&!output.option("screw_ie8")){make_block(self.body,output);return}var b=self.body;while(true){if(b instanceof AST_If){if(!b.alternative){make_block(self.body,output);return}b=b.alternative}else if(b instanceof AST_StatementWithBody){b=b.body}else break}force_statement(self.body,output)}DEFPRINT(AST_If,function(self,output){output.print("if");output.space();output.with_parens(function(){self.condition.print(output)});output.space();if(self.alternative){make_then(self,output);output.space();output.print("else");output.space();force_statement(self.alternative,output)}else{self._do_print_body(output)}});DEFPRINT(AST_Switch,function(self,output){output.print("switch");output.space();output.with_parens(function(){self.expression.print(output)});output.space();if(self.body.length>0)output.with_block(function(){self.body.forEach(function(stmt,i){if(i)output.newline();output.indent(true);stmt.print(output)})});else output.print("{}")});AST_SwitchBranch.DEFMETHOD("_do_print_body",function(output){if(this.body.length>0){output.newline();this.body.forEach(function(stmt){output.indent();stmt.print(output);output.newline()})}});DEFPRINT(AST_Default,function(self,output){output.print("default:");self._do_print_body(output)});DEFPRINT(AST_Case,function(self,output){output.print("case");output.space();self.expression.print(output);output.print(":");self._do_print_body(output)});DEFPRINT(AST_Try,function(self,output){output.print("try");output.space();print_bracketed(self.body,output);if(self.bcatch){output.space();self.bcatch.print(output)}if(self.bfinally){output.space();self.bfinally.print(output)}});DEFPRINT(AST_Catch,function(self,output){output.print("catch");output.space();output.with_parens(function(){self.argname.print(output)});output.space();print_bracketed(self.body,output)});DEFPRINT(AST_Finally,function(self,output){output.print("finally");output.space();print_bracketed(self.body,output)});AST_Definitions.DEFMETHOD("_do_print",function(output,kind){output.print(kind);output.space();this.definitions.forEach(function(def,i){if(i)output.comma();def.print(output)});var p=output.parent();var in_for=p instanceof AST_For||p instanceof AST_ForIn;var avoid_semicolon=in_for&&p.init===this;if(!avoid_semicolon)output.semicolon()});DEFPRINT(AST_Var,function(self,output){self._do_print(output,"var")});DEFPRINT(AST_Const,function(self,output){self._do_print(output,"const")});function parenthesize_for_noin(node,output,noin){if(!noin)node.print(output);else try{node.walk(new TreeWalker(function(node){if(node instanceof AST_Binary&&node.operator=="in")throw output}));node.print(output)}catch(ex){if(ex!==output)throw ex;node.print(output,true)}}DEFPRINT(AST_VarDef,function(self,output){self.name.print(output);if(self.value){output.space();output.print("=");output.space();var p=output.parent(1);var noin=p instanceof AST_For||p instanceof AST_ForIn;parenthesize_for_noin(self.value,output,noin)}});DEFPRINT(AST_Call,function(self,output){self.expression.print(output);if(self instanceof AST_New&&no_constructor_parens(self,output))return;output.with_parens(function(){self.args.forEach(function(expr,i){if(i)output.comma();expr.print(output)})})});DEFPRINT(AST_New,function(self,output){output.print("new");output.space();AST_Call.prototype._codegen(self,output)});AST_Seq.DEFMETHOD("_do_print",function(output){this.car.print(output);if(this.cdr){output.comma();if(output.should_break()){output.newline();output.indent()}this.cdr.print(output)}});DEFPRINT(AST_Seq,function(self,output){self._do_print(output)});DEFPRINT(AST_Dot,function(self,output){var expr=self.expression;expr.print(output);if(expr instanceof AST_Number&&expr.getValue()>=0){if(!/[xa-f.]/i.test(output.last())){output.print(".")}}output.print(".");output.add_mapping(self.end);output.print_name(self.property)});DEFPRINT(AST_Sub,function(self,output){self.expression.print(output);output.print("[");self.property.print(output);output.print("]")});DEFPRINT(AST_UnaryPrefix,function(self,output){var op=self.operator;output.print(op);if(/^[a-z]/i.test(op)||/[+-]$/.test(op)&&self.expression instanceof AST_UnaryPrefix&&/^[+-]/.test(self.expression.operator)){output.space()}self.expression.print(output)});DEFPRINT(AST_UnaryPostfix,function(self,output){self.expression.print(output);output.print(self.operator)});DEFPRINT(AST_Binary,function(self,output){self.left.print(output);output.space();output.print(self.operator);if(self.operator=="<"&&self.right instanceof AST_UnaryPrefix&&self.right.operator=="!"&&self.right.expression instanceof AST_UnaryPrefix&&self.right.expression.operator=="--"){output.print(" ")}else{output.space()}self.right.print(output)});DEFPRINT(AST_Conditional,function(self,output){self.condition.print(output);output.space();output.print("?");output.space();self.consequent.print(output);output.space();output.colon();self.alternative.print(output)});DEFPRINT(AST_Array,function(self,output){output.with_square(function(){var a=self.elements,len=a.length;if(len>0)output.space();a.forEach(function(exp,i){if(i)output.comma();exp.print(output);if(i===len-1&&exp instanceof AST_Hole)output.comma()});if(len>0)output.space()})});DEFPRINT(AST_Object,function(self,output){if(self.properties.length>0)output.with_block(function(){self.properties.forEach(function(prop,i){if(i){output.print(",");output.newline()}output.indent();prop.print(output)});output.newline()});else output.print("{}")});DEFPRINT(AST_ObjectKeyVal,function(self,output){var key=self.key;if(output.option("quote_keys")){output.print_string(key+"")}else if((typeof key=="number"||!output.option("beautify")&&+key+""==key)&&parseFloat(key)>=0){output.print(make_num(key))}else if(RESERVED_WORDS(key)?output.option("screw_ie8"):is_identifier_string(key)){output.print_name(key)}else{output.print_string(key)}output.colon();self.value.print(output)});DEFPRINT(AST_ObjectSetter,function(self,output){output.print("set");output.space();self.key.print(output);self.value._do_print(output,true)});DEFPRINT(AST_ObjectGetter,function(self,output){output.print("get");output.space();self.key.print(output);self.value._do_print(output,true)});DEFPRINT(AST_Symbol,function(self,output){var def=self.definition();output.print_name(def?def.mangled_name||def.name:self.name)});DEFPRINT(AST_Undefined,function(self,output){output.print("void 0")});DEFPRINT(AST_Hole,noop);DEFPRINT(AST_Infinity,function(self,output){output.print("1/0")});DEFPRINT(AST_NaN,function(self,output){output.print("0/0")});DEFPRINT(AST_This,function(self,output){output.print("this")});DEFPRINT(AST_Constant,function(self,output){output.print(self.getValue())});DEFPRINT(AST_String,function(self,output){output.print_string(self.getValue())});DEFPRINT(AST_Number,function(self,output){output.print(make_num(self.getValue()))});function regexp_safe_literal(code){return[92,47,46,43,42,63,40,41,91,93,123,125,36,94,58,124,33,10,13,0,65279,8232,8233].indexOf(code)<0}DEFPRINT(AST_RegExp,function(self,output){var str=self.getValue().toString();if(output.option("ascii_only")){str=output.to_ascii(str)}else if(output.option("unescape_regexps")){str=str.split("\\\\").map(function(str){return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g,function(s){var code=parseInt(s.substr(2),16);return regexp_safe_literal(code)?String.fromCharCode(code):s})}).join("\\\\")}output.print(str);var p=output.parent();if(p instanceof AST_Binary&&/^in/.test(p.operator)&&p.left===self)output.print(" ")});function force_statement(stat,output){if(output.option("bracketize")){if(!stat||stat instanceof AST_EmptyStatement)output.print("{}");else if(stat instanceof AST_BlockStatement)stat.print(output);else output.with_block(function(){output.indent();stat.print(output);output.newline()})}else{if(!stat||stat instanceof AST_EmptyStatement)output.force_semicolon();else stat.print(output)}}function first_in_statement(output){var a=output.stack(),i=a.length,node=a[--i],p=a[--i];while(i>0){if(p instanceof AST_Statement&&p.body===node)return true;if(p instanceof AST_Seq&&p.car===node||p instanceof AST_Call&&p.expression===node&&!(p instanceof AST_New)||p instanceof AST_Dot&&p.expression===node||p instanceof AST_Sub&&p.expression===node||p instanceof AST_Conditional&&p.condition===node||p instanceof AST_Binary&&p.left===node||p instanceof AST_UnaryPostfix&&p.expression===node){node=p;p=a[--i]}else{return false}}}function no_constructor_parens(self,output){return self.args.length==0&&!output.option("beautify")}function best_of(a){var best=a[0],len=best.length;for(var i=1;i<a.length;++i){if(a[i].length<len){best=a[i];len=best.length}}return best}function make_num(num){var str=num.toString(10),a=[str.replace(/^0\./,".").replace("e+","e")],m;if(Math.floor(num)===num){if(num>=0){a.push("0x"+num.toString(16).toLowerCase(),"0"+num.toString(8))}else{a.push("-0x"+(-num).toString(16).toLowerCase(),"-0"+(-num).toString(8))}if(m=/^(.*?)(0+)$/.exec(num)){a.push(m[1]+"e"+m[2].length)}}else if(m=/^0?\.(0+)(.*)$/.exec(num)){a.push(m[2]+"e-"+(m[1].length+m[2].length),str.substr(str.indexOf(".")))}return best_of(a)}function make_block(stmt,output){if(stmt instanceof AST_BlockStatement){stmt.print(output);return}output.with_block(function(){output.indent();stmt.print(output);output.newline()})}function DEFMAP(nodetype,generator){nodetype.DEFMETHOD("add_source_map",function(stream){generator(this,stream)})}DEFMAP(AST_Node,noop);function basic_sourcemap_gen(self,output){output.add_mapping(self.start)}DEFMAP(AST_Directive,basic_sourcemap_gen);DEFMAP(AST_Debugger,basic_sourcemap_gen);DEFMAP(AST_Symbol,basic_sourcemap_gen);DEFMAP(AST_Jump,basic_sourcemap_gen);DEFMAP(AST_StatementWithBody,basic_sourcemap_gen);DEFMAP(AST_LabeledStatement,noop);DEFMAP(AST_Lambda,basic_sourcemap_gen);DEFMAP(AST_Switch,basic_sourcemap_gen);DEFMAP(AST_SwitchBranch,basic_sourcemap_gen);DEFMAP(AST_BlockStatement,basic_sourcemap_gen);DEFMAP(AST_Toplevel,noop);DEFMAP(AST_New,basic_sourcemap_gen);DEFMAP(AST_Try,basic_sourcemap_gen);DEFMAP(AST_Catch,basic_sourcemap_gen);DEFMAP(AST_Finally,basic_sourcemap_gen);DEFMAP(AST_Definitions,basic_sourcemap_gen);DEFMAP(AST_Constant,basic_sourcemap_gen);DEFMAP(AST_ObjectProperty,function(self,output){output.add_mapping(self.start,self.key)})})();/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function Compressor(options,false_by_default){if(!(this instanceof Compressor))return new Compressor(options,false_by_default);TreeTransformer.call(this,this.before,this.after);this.options=defaults(options,{sequences:!false_by_default,properties:!false_by_default,dead_code:!false_by_default,drop_debugger:!false_by_default,unsafe:false,unsafe_comps:false,conditionals:!false_by_default,comparisons:!false_by_default,evaluate:!false_by_default,booleans:!false_by_default,loops:!false_by_default,unused:!false_by_default,hoist_funs:!false_by_default,keep_fargs:false,hoist_vars:false,if_return:!false_by_default,join_vars:!false_by_default,cascade:!false_by_default,side_effects:!false_by_default,pure_getters:false,pure_funcs:null,negate_iife:!false_by_default,screw_ie8:false,drop_console:false,angular:false,warnings:true,global_defs:{}},true)}Compressor.prototype=new TreeTransformer;merge(Compressor.prototype,{option:function(key){return this.options[key]},warn:function(){if(this.options.warnings)AST_Node.warn.apply(AST_Node,arguments)},before:function(node,descend,in_list){if(node._squeezed)return node;var was_scope=false;if(node instanceof AST_Scope){node=node.hoist_declarations(this);was_scope=true}descend(node,this);node=node.optimize(this);if(was_scope&&node instanceof AST_Scope){node.drop_unused(this);descend(node,this)}node._squeezed=true;return node}});(function(){function OPT(node,optimizer){node.DEFMETHOD("optimize",function(compressor){var self=this;if(self._optimized)return self;var opt=optimizer(self,compressor);opt._optimized=true;if(opt===self)return opt;return opt.transform(compressor)})}OPT(AST_Node,function(self,compressor){return self});AST_Node.DEFMETHOD("equivalent_to",function(node){return this.print_to_string()==node.print_to_string()});function make_node(ctor,orig,props){if(!props)props={};if(orig){if(!props.start)props.start=orig.start;if(!props.end)props.end=orig.end}return new ctor(props)}function make_node_from_constant(compressor,val,orig){if(val instanceof AST_Node)return val.transform(compressor);switch(typeof val){case"string":return make_node(AST_String,orig,{value:val}).optimize(compressor);case"number":return make_node(isNaN(val)?AST_NaN:AST_Number,orig,{value:val}).optimize(compressor);case"boolean":return make_node(val?AST_True:AST_False,orig).optimize(compressor);case"undefined":return make_node(AST_Undefined,orig).optimize(compressor);default:if(val===null){return make_node(AST_Null,orig).optimize(compressor)}if(val instanceof RegExp){return make_node(AST_RegExp,orig).optimize(compressor)}throw new Error(string_template("Can't handle constant of type: {type}",{type:typeof val}))}}function as_statement_array(thing){if(thing===null)return[];if(thing instanceof AST_BlockStatement)return thing.body;if(thing instanceof AST_EmptyStatement)return[];if(thing instanceof AST_Statement)return[thing];throw new Error("Can't convert thing to statement array")}function is_empty(thing){if(thing===null)return true;if(thing instanceof AST_EmptyStatement)return true;if(thing instanceof AST_BlockStatement)return thing.body.length==0;return false}function loop_body(x){if(x instanceof AST_Switch)return x;if(x instanceof AST_For||x instanceof AST_ForIn||x instanceof AST_DWLoop){return x.body instanceof AST_BlockStatement?x.body:x}return x}function tighten_body(statements,compressor){var CHANGED;do{CHANGED=false;if(compressor.option("angular")){statements=process_for_angular(statements)}statements=eliminate_spurious_blocks(statements);if(compressor.option("dead_code")){statements=eliminate_dead_code(statements,compressor)}if(compressor.option("if_return")){statements=handle_if_return(statements,compressor)}if(compressor.option("sequences")){statements=sequencesize(statements,compressor)}if(compressor.option("join_vars")){statements=join_consecutive_vars(statements,compressor)}}while(CHANGED);if(compressor.option("negate_iife")){negate_iifes(statements,compressor)}return statements;function process_for_angular(statements){function make_injector(func,name){return make_node(AST_SimpleStatement,func,{body:make_node(AST_Assign,func,{operator:"=",left:make_node(AST_Dot,name,{expression:make_node(AST_SymbolRef,name,name),property:"$inject"}),right:make_node(AST_Array,func,{elements:func.argnames.map(function(sym){return make_node(AST_String,sym,{value:sym.name})})})})})}return statements.reduce(function(a,stat){a.push(stat);var token=stat.start;var comments=token.comments_before;if(comments&&comments.length>0){var last=comments.pop();if(/@ngInject/.test(last.value)){if(stat instanceof AST_Defun){a.push(make_injector(stat,stat.name))}else if(stat instanceof AST_Definitions){stat.definitions.forEach(function(def){if(def.value&&def.value instanceof AST_Lambda){a.push(make_injector(def.value,def.name))}})}else{compressor.warn("Unknown statement marked with @ngInject [{file}:{line},{col}]",token)}}}return a},[])}function eliminate_spurious_blocks(statements){var seen_dirs=[];return statements.reduce(function(a,stat){if(stat instanceof AST_BlockStatement){CHANGED=true;a.push.apply(a,eliminate_spurious_blocks(stat.body))}else if(stat instanceof AST_EmptyStatement){CHANGED=true}else if(stat instanceof AST_Directive){if(seen_dirs.indexOf(stat.value)<0){a.push(stat);seen_dirs.push(stat.value)}else{CHANGED=true}}else{a.push(stat)}return a},[])}function handle_if_return(statements,compressor){var self=compressor.self();var in_lambda=self instanceof AST_Lambda;var ret=[];loop:for(var i=statements.length;--i>=0;){var stat=statements[i];switch(true){case in_lambda&&stat instanceof AST_Return&&!stat.value&&ret.length==0:CHANGED=true;continue loop;case stat instanceof AST_If:if(stat.body instanceof AST_Return){if((in_lambda&&ret.length==0||ret[0]instanceof AST_Return&&!ret[0].value)&&!stat.body.value&&!stat.alternative){CHANGED=true;var cond=make_node(AST_SimpleStatement,stat.condition,{body:stat.condition});ret.unshift(cond);continue loop}if(ret[0]instanceof AST_Return&&stat.body.value&&ret[0].value&&!stat.alternative){CHANGED=true;stat=stat.clone();stat.alternative=ret[0];ret[0]=stat.transform(compressor);continue loop}if((ret.length==0||ret[0]instanceof AST_Return)&&stat.body.value&&!stat.alternative&&in_lambda){CHANGED=true;stat=stat.clone();stat.alternative=ret[0]||make_node(AST_Return,stat,{value:make_node(AST_Undefined,stat)});ret[0]=stat.transform(compressor);continue loop}if(!stat.body.value&&in_lambda){CHANGED=true;stat=stat.clone();stat.condition=stat.condition.negate(compressor);stat.body=make_node(AST_BlockStatement,stat,{body:as_statement_array(stat.alternative).concat(ret)});stat.alternative=null;ret=[stat.transform(compressor)];continue loop}if(ret.length==1&&in_lambda&&ret[0]instanceof AST_SimpleStatement&&(!stat.alternative||stat.alternative instanceof AST_SimpleStatement)){CHANGED=true;ret.push(make_node(AST_Return,ret[0],{value:make_node(AST_Undefined,ret[0])}).transform(compressor));ret=as_statement_array(stat.alternative).concat(ret);ret.unshift(stat);continue loop}}var ab=aborts(stat.body);var lct=ab instanceof AST_LoopControl?compressor.loopcontrol_target(ab.label):null;if(ab&&(ab instanceof AST_Return&&!ab.value&&in_lambda||ab instanceof AST_Continue&&self===loop_body(lct)||ab instanceof AST_Break&&lct instanceof AST_BlockStatement&&self===lct)){if(ab.label){remove(ab.label.thedef.references,ab)}CHANGED=true;var body=as_statement_array(stat.body).slice(0,-1);stat=stat.clone();stat.condition=stat.condition.negate(compressor);stat.body=make_node(AST_BlockStatement,stat,{body:as_statement_array(stat.alternative).concat(ret)});stat.alternative=make_node(AST_BlockStatement,stat,{body:body});ret=[stat.transform(compressor)];continue loop}var ab=aborts(stat.alternative);var lct=ab instanceof AST_LoopControl?compressor.loopcontrol_target(ab.label):null;if(ab&&(ab instanceof AST_Return&&!ab.value&&in_lambda||ab instanceof AST_Continue&&self===loop_body(lct)||ab instanceof AST_Break&&lct instanceof AST_BlockStatement&&self===lct)){if(ab.label){remove(ab.label.thedef.references,ab)}CHANGED=true;stat=stat.clone();stat.body=make_node(AST_BlockStatement,stat.body,{body:as_statement_array(stat.body).concat(ret)});stat.alternative=make_node(AST_BlockStatement,stat.alternative,{body:as_statement_array(stat.alternative).slice(0,-1)});ret=[stat.transform(compressor)];continue loop}ret.unshift(stat);break;default:ret.unshift(stat);break}}return ret}function eliminate_dead_code(statements,compressor){var has_quit=false;var orig=statements.length;var self=compressor.self();statements=statements.reduce(function(a,stat){if(has_quit){extract_declarations_from_unreachable_code(compressor,stat,a)}else{if(stat instanceof AST_LoopControl){var lct=compressor.loopcontrol_target(stat.label);if(stat instanceof AST_Break&&lct instanceof AST_BlockStatement&&loop_body(lct)===self||stat instanceof AST_Continue&&loop_body(lct)===self){if(stat.label){remove(stat.label.thedef.references,stat)}}else{a.push(stat)}}else{a.push(stat)}if(aborts(stat))has_quit=true}return a},[]);CHANGED=statements.length!=orig;return statements}function sequencesize(statements,compressor){if(statements.length<2)return statements;var seq=[],ret=[];function push_seq(){seq=AST_Seq.from_array(seq);if(seq)ret.push(make_node(AST_SimpleStatement,seq,{body:seq}));seq=[]}statements.forEach(function(stat){if(stat instanceof AST_SimpleStatement)seq.push(stat.body);else push_seq(),ret.push(stat)});push_seq();ret=sequencesize_2(ret,compressor);CHANGED=ret.length!=statements.length;return ret}function sequencesize_2(statements,compressor){function cons_seq(right){ret.pop();var left=prev.body;if(left instanceof AST_Seq){left.add(right)}else{left=AST_Seq.cons(left,right)}return left.transform(compressor)}var ret=[],prev=null;statements.forEach(function(stat){if(prev){if(stat instanceof AST_For){var opera={};try{prev.body.walk(new TreeWalker(function(node){if(node instanceof AST_Binary&&node.operator=="in")throw opera}));if(stat.init&&!(stat.init instanceof AST_Definitions)){stat.init=cons_seq(stat.init)}else if(!stat.init){stat.init=prev.body;ret.pop()}}catch(ex){if(ex!==opera)throw ex}}else if(stat instanceof AST_If){stat.condition=cons_seq(stat.condition)}else if(stat instanceof AST_With){stat.expression=cons_seq(stat.expression)}else if(stat instanceof AST_Exit&&stat.value){stat.value=cons_seq(stat.value)}else if(stat instanceof AST_Exit){stat.value=cons_seq(make_node(AST_Undefined,stat))}else if(stat instanceof AST_Switch){stat.expression=cons_seq(stat.expression)}}ret.push(stat);prev=stat instanceof AST_SimpleStatement?stat:null});return ret}function join_consecutive_vars(statements,compressor){var prev=null;return statements.reduce(function(a,stat){if(stat instanceof AST_Definitions&&prev&&prev.TYPE==stat.TYPE){prev.definitions=prev.definitions.concat(stat.definitions);CHANGED=true}else if(stat instanceof AST_For&&prev instanceof AST_Definitions&&(!stat.init||stat.init.TYPE==prev.TYPE)){CHANGED=true;a.pop();if(stat.init){stat.init.definitions=prev.definitions.concat(stat.init.definitions)}else{stat.init=prev}a.push(stat);prev=stat}else{prev=stat;a.push(stat)}return a},[])}function negate_iifes(statements,compressor){statements.forEach(function(stat){if(stat instanceof AST_SimpleStatement){stat.body=function transform(thing){return thing.transform(new TreeTransformer(function(node){if(node instanceof AST_Call&&node.expression instanceof AST_Function){return make_node(AST_UnaryPrefix,node,{operator:"!",expression:node})}else if(node instanceof AST_Call){node.expression=transform(node.expression)}else if(node instanceof AST_Seq){node.car=transform(node.car)}else if(node instanceof AST_Conditional){var expr=transform(node.condition);if(expr!==node.condition){node.condition=expr;var tmp=node.consequent;node.consequent=node.alternative;node.alternative=tmp}}return node}))}(stat.body)}})}}function extract_declarations_from_unreachable_code(compressor,stat,target){compressor.warn("Dropping unreachable code [{file}:{line},{col}]",stat.start);stat.walk(new TreeWalker(function(node){if(node instanceof AST_Definitions){compressor.warn("Declarations in unreachable code! [{file}:{line},{col}]",node.start);node.remove_initializers();target.push(node);return true}if(node instanceof AST_Defun){target.push(node);return true}if(node instanceof AST_Scope){return true}}))}(function(def){var unary_bool=["!","delete"];var binary_bool=["in","instanceof","==","!=","===","!==","<","<=",">=",">"];def(AST_Node,function(){return false});def(AST_UnaryPrefix,function(){return member(this.operator,unary_bool)});def(AST_Binary,function(){return member(this.operator,binary_bool)||(this.operator=="&&"||this.operator=="||")&&this.left.is_boolean()&&this.right.is_boolean()});def(AST_Conditional,function(){return this.consequent.is_boolean()&&this.alternative.is_boolean()});def(AST_Assign,function(){return this.operator=="="&&this.right.is_boolean()});def(AST_Seq,function(){return this.cdr.is_boolean()});def(AST_True,function(){return true});def(AST_False,function(){return true})})(function(node,func){node.DEFMETHOD("is_boolean",func)});(function(def){def(AST_Node,function(){return false});def(AST_String,function(){return true});def(AST_UnaryPrefix,function(){return this.operator=="typeof"});def(AST_Binary,function(compressor){return this.operator=="+"&&(this.left.is_string(compressor)||this.right.is_string(compressor))});def(AST_Assign,function(compressor){return(this.operator=="="||this.operator=="+=")&&this.right.is_string(compressor)});def(AST_Seq,function(compressor){return this.cdr.is_string(compressor)});def(AST_Conditional,function(compressor){return this.consequent.is_string(compressor)&&this.alternative.is_string(compressor)});def(AST_Call,function(compressor){return compressor.option("unsafe")&&this.expression instanceof AST_SymbolRef&&this.expression.name=="String"&&this.expression.undeclared()})})(function(node,func){node.DEFMETHOD("is_string",func)});function best_of(ast1,ast2){return ast1.print_to_string().length>ast2.print_to_string().length?ast2:ast1}(function(def){AST_Node.DEFMETHOD("evaluate",function(compressor){if(!compressor.option("evaluate"))return[this];try{var val=this._eval(compressor);return[best_of(make_node_from_constant(compressor,val,this),this),val]}catch(ex){if(ex!==def)throw ex;return[this]}});def(AST_Statement,function(){throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]",this.start))});def(AST_Function,function(){throw def});function ev(node,compressor){if(!compressor)throw new Error("Compressor must be passed");return node._eval(compressor)}def(AST_Node,function(){throw def});def(AST_Constant,function(){return this.getValue()});def(AST_UnaryPrefix,function(compressor){var e=this.expression;switch(this.operator){case"!":return!ev(e,compressor);case"typeof":if(e instanceof AST_Function)return typeof function(){};e=ev(e,compressor);if(e instanceof RegExp)throw def;return typeof e;case"void":return void ev(e,compressor);case"~":return~ev(e,compressor);case"-":e=ev(e,compressor);if(e===0)throw def;return-e;case"+":return+ev(e,compressor)}throw def});def(AST_Binary,function(c){var left=this.left,right=this.right;switch(this.operator){case"&&":return ev(left,c)&&ev(right,c);case"||":return ev(left,c)||ev(right,c);case"|":return ev(left,c)|ev(right,c);case"&":return ev(left,c)&ev(right,c);case"^":return ev(left,c)^ev(right,c);case"+":return ev(left,c)+ev(right,c);case"*":return ev(left,c)*ev(right,c);case"/":return ev(left,c)/ev(right,c);case"%":return ev(left,c)%ev(right,c);case"-":return ev(left,c)-ev(right,c);case"<<":return ev(left,c)<<ev(right,c);case">>":return ev(left,c)>>ev(right,c);case">>>":return ev(left,c)>>>ev(right,c);case"==":return ev(left,c)==ev(right,c);case"===":return ev(left,c)===ev(right,c);case"!=":return ev(left,c)!=ev(right,c);case"!==":return ev(left,c)!==ev(right,c);case"<":return ev(left,c)<ev(right,c);case"<=":return ev(left,c)<=ev(right,c);case">":return ev(left,c)>ev(right,c);case">=":return ev(left,c)>=ev(right,c);case"in":return ev(left,c)in ev(right,c);case"instanceof":return ev(left,c)instanceof ev(right,c)}throw def});def(AST_Conditional,function(compressor){return ev(this.condition,compressor)?ev(this.consequent,compressor):ev(this.alternative,compressor)});def(AST_SymbolRef,function(compressor){var d=this.definition();if(d&&d.constant&&d.init)return ev(d.init,compressor);throw def});def(AST_Dot,function(compressor){if(compressor.option("unsafe")&&this.property=="length"){var str=ev(this.expression,compressor);if(typeof str=="string")return str.length}throw def})})(function(node,func){node.DEFMETHOD("_eval",func)});(function(def){function basic_negation(exp){return make_node(AST_UnaryPrefix,exp,{operator:"!",expression:exp})}def(AST_Node,function(){return basic_negation(this)});def(AST_Statement,function(){throw new Error("Cannot negate a statement")});def(AST_Function,function(){return basic_negation(this)});def(AST_UnaryPrefix,function(){if(this.operator=="!")return this.expression;return basic_negation(this)});def(AST_Seq,function(compressor){var self=this.clone();self.cdr=self.cdr.negate(compressor);return self});def(AST_Conditional,function(compressor){var self=this.clone();self.consequent=self.consequent.negate(compressor);self.alternative=self.alternative.negate(compressor);return best_of(basic_negation(this),self)});def(AST_Binary,function(compressor){var self=this.clone(),op=this.operator;if(compressor.option("unsafe_comps")){switch(op){case"<=":self.operator=">";return self;case"<":self.operator=">=";return self;case">=":self.operator="<";return self;case">":self.operator="<=";return self}}switch(op){case"==":self.operator="!=";return self;case"!=":self.operator="==";return self;case"===":self.operator="!==";return self;case"!==":self.operator="===";return self;case"&&":self.operator="||";self.left=self.left.negate(compressor);self.right=self.right.negate(compressor);return best_of(basic_negation(this),self);case"||":self.operator="&&";self.left=self.left.negate(compressor);self.right=self.right.negate(compressor);return best_of(basic_negation(this),self)}return basic_negation(this)})})(function(node,func){node.DEFMETHOD("negate",function(compressor){return func.call(this,compressor)})});(function(def){def(AST_Node,function(compressor){return true});def(AST_EmptyStatement,function(compressor){return false});def(AST_Constant,function(compressor){return false});def(AST_This,function(compressor){return false});def(AST_Call,function(compressor){var pure=compressor.option("pure_funcs");if(!pure)return true;return pure.indexOf(this.expression.print_to_string())<0});def(AST_Block,function(compressor){for(var i=this.body.length;--i>=0;){if(this.body[i].has_side_effects(compressor))return true}return false});def(AST_SimpleStatement,function(compressor){return this.body.has_side_effects(compressor)});def(AST_Defun,function(compressor){return true});def(AST_Function,function(compressor){return false});def(AST_Binary,function(compressor){return this.left.has_side_effects(compressor)||this.right.has_side_effects(compressor)});def(AST_Assign,function(compressor){return true});def(AST_Conditional,function(compressor){return this.condition.has_side_effects(compressor)||this.consequent.has_side_effects(compressor)||this.alternative.has_side_effects(compressor)});def(AST_Unary,function(compressor){return this.operator=="delete"||this.operator=="++"||this.operator=="--"||this.expression.has_side_effects(compressor)});def(AST_SymbolRef,function(compressor){return this.global()&&this.undeclared()});def(AST_Object,function(compressor){for(var i=this.properties.length;--i>=0;)if(this.properties[i].has_side_effects(compressor))return true;return false});def(AST_ObjectProperty,function(compressor){return this.value.has_side_effects(compressor)});def(AST_Array,function(compressor){for(var i=this.elements.length;--i>=0;)if(this.elements[i].has_side_effects(compressor))return true;return false});def(AST_Dot,function(compressor){if(!compressor.option("pure_getters"))return true;return this.expression.has_side_effects(compressor)});def(AST_Sub,function(compressor){if(!compressor.option("pure_getters"))return true;return this.expression.has_side_effects(compressor)||this.property.has_side_effects(compressor)});def(AST_PropAccess,function(compressor){return!compressor.option("pure_getters")});def(AST_Seq,function(compressor){return this.car.has_side_effects(compressor)||this.cdr.has_side_effects(compressor)})})(function(node,func){node.DEFMETHOD("has_side_effects",func)});function aborts(thing){return thing&&thing.aborts()}(function(def){def(AST_Statement,function(){return null});def(AST_Jump,function(){return this});function block_aborts(){var n=this.body.length;return n>0&&aborts(this.body[n-1])}def(AST_BlockStatement,block_aborts);def(AST_SwitchBranch,block_aborts);def(AST_If,function(){return this.alternative&&aborts(this.body)&&aborts(this.alternative)})})(function(node,func){node.DEFMETHOD("aborts",func)});OPT(AST_Directive,function(self,compressor){if(self.scope.has_directive(self.value)!==self.scope){return make_node(AST_EmptyStatement,self)}return self});OPT(AST_Debugger,function(self,compressor){if(compressor.option("drop_debugger"))return make_node(AST_EmptyStatement,self);return self});OPT(AST_LabeledStatement,function(self,compressor){if(self.body instanceof AST_Break&&compressor.loopcontrol_target(self.body.label)===self.body){return make_node(AST_EmptyStatement,self)}return self.label.references.length==0?self.body:self});OPT(AST_Block,function(self,compressor){self.body=tighten_body(self.body,compressor);return self});OPT(AST_BlockStatement,function(self,compressor){self.body=tighten_body(self.body,compressor);switch(self.body.length){case 1:return self.body[0];case 0:return make_node(AST_EmptyStatement,self)}return self});AST_Scope.DEFMETHOD("drop_unused",function(compressor){var self=this;if(compressor.option("unused")&&!(self instanceof AST_Toplevel)&&!self.uses_eval){var in_use=[];var initializations=new Dictionary;var scope=this;var tw=new TreeWalker(function(node,descend){if(node!==self){if(node instanceof AST_Defun){initializations.add(node.name.name,node);return true}if(node instanceof AST_Definitions&&scope===self){node.definitions.forEach(function(def){if(def.value){initializations.add(def.name.name,def.value);if(def.value.has_side_effects(compressor)){def.value.walk(tw)}}});return true}if(node instanceof AST_SymbolRef){push_uniq(in_use,node.definition());return true}if(node instanceof AST_Scope){var save_scope=scope;scope=node;descend();scope=save_scope;return true}}});self.walk(tw);for(var i=0;i<in_use.length;++i){in_use[i].orig.forEach(function(decl){var init=initializations.get(decl.name);if(init)init.forEach(function(init){var tw=new TreeWalker(function(node){if(node instanceof AST_SymbolRef){push_uniq(in_use,node.definition())}});init.walk(tw)})})}var tt=new TreeTransformer(function before(node,descend,in_list){if(node instanceof AST_Lambda&&!(node instanceof AST_Accessor)){if(!compressor.option("keep_fargs")){for(var a=node.argnames,i=a.length;--i>=0;){var sym=a[i];if(sym.unreferenced()){a.pop();compressor.warn("Dropping unused function argument {name} [{file}:{line},{col}]",{name:sym.name,file:sym.start.file,line:sym.start.line,col:sym.start.col})}else break}}}if(node instanceof AST_Defun&&node!==self){if(!member(node.name.definition(),in_use)){compressor.warn("Dropping unused function {name} [{file}:{line},{col}]",{name:node.name.name,file:node.name.start.file,line:node.name.start.line,col:node.name.start.col});return make_node(AST_EmptyStatement,node)}return node}if(node instanceof AST_Definitions&&!(tt.parent()instanceof AST_ForIn)){var def=node.definitions.filter(function(def){if(member(def.name.definition(),in_use))return true;var w={name:def.name.name,file:def.name.start.file,line:def.name.start.line,col:def.name.start.col};if(def.value&&def.value.has_side_effects(compressor)){def._unused_side_effects=true;compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]",w);return true}compressor.warn("Dropping unused variable {name} [{file}:{line},{col}]",w);return false});def=mergeSort(def,function(a,b){if(!a.value&&b.value)return-1;if(!b.value&&a.value)return 1;return 0});var side_effects=[];for(var i=0;i<def.length;){var x=def[i];if(x._unused_side_effects){side_effects.push(x.value);def.splice(i,1)}else{if(side_effects.length>0){side_effects.push(x.value);x.value=AST_Seq.from_array(side_effects);side_effects=[]}++i}}if(side_effects.length>0){side_effects=make_node(AST_BlockStatement,node,{body:[make_node(AST_SimpleStatement,node,{body:AST_Seq.from_array(side_effects)})]})}else{side_effects=null}if(def.length==0&&!side_effects){return make_node(AST_EmptyStatement,node)}if(def.length==0){return side_effects}node.definitions=def;if(side_effects){side_effects.body.unshift(node);node=side_effects}return node}if(node instanceof AST_For){descend(node,this);if(node.init instanceof AST_BlockStatement){var body=node.init.body.slice(0,-1);node.init=node.init.body.slice(-1)[0].body;body.push(node);return in_list?MAP.splice(body):make_node(AST_BlockStatement,node,{body:body})}}if(node instanceof AST_Scope&&node!==self)return node});self.transform(tt)}});AST_Scope.DEFMETHOD("hoist_declarations",function(compressor){var hoist_funs=compressor.option("hoist_funs");var hoist_vars=compressor.option("hoist_vars");var self=this;if(hoist_funs||hoist_vars){var dirs=[];var hoisted=[];var vars=new Dictionary,vars_found=0,var_decl=0;self.walk(new TreeWalker(function(node){if(node instanceof AST_Scope&&node!==self)return true;if(node instanceof AST_Var){++var_decl;return true}}));hoist_vars=hoist_vars&&var_decl>1;var tt=new TreeTransformer(function before(node){if(node!==self){if(node instanceof AST_Directive){dirs.push(node);return make_node(AST_EmptyStatement,node)}if(node instanceof AST_Defun&&hoist_funs){hoisted.push(node);return make_node(AST_EmptyStatement,node)}if(node instanceof AST_Var&&hoist_vars){node.definitions.forEach(function(def){vars.set(def.name.name,def);++vars_found});var seq=node.to_assignments();var p=tt.parent();if(p instanceof AST_ForIn&&p.init===node){if(seq==null)return node.definitions[0].name;return seq}if(p instanceof AST_For&&p.init===node){return seq}if(!seq)return make_node(AST_EmptyStatement,node);return make_node(AST_SimpleStatement,node,{body:seq})}if(node instanceof AST_Scope)return node}});self=self.transform(tt);if(vars_found>0){var defs=[];vars.each(function(def,name){if(self instanceof AST_Lambda&&find_if(function(x){return x.name==def.name.name},self.argnames)){vars.del(name)}else{def=def.clone();def.value=null;defs.push(def);vars.set(name,def)}});if(defs.length>0){for(var i=0;i<self.body.length;){if(self.body[i]instanceof AST_SimpleStatement){var expr=self.body[i].body,sym,assign;if(expr instanceof AST_Assign&&expr.operator=="="&&(sym=expr.left)instanceof AST_Symbol&&vars.has(sym.name)){var def=vars.get(sym.name);if(def.value)break;def.value=expr.right;remove(defs,def);defs.push(def);self.body.splice(i,1);continue}if(expr instanceof AST_Seq&&(assign=expr.car)instanceof AST_Assign&&assign.operator=="="&&(sym=assign.left)instanceof AST_Symbol&&vars.has(sym.name)){var def=vars.get(sym.name);if(def.value)break;def.value=assign.right;remove(defs,def);defs.push(def);self.body[i].body=expr.cdr;continue}}if(self.body[i]instanceof AST_EmptyStatement){self.body.splice(i,1);continue}if(self.body[i]instanceof AST_BlockStatement){var tmp=[i,1].concat(self.body[i].body);self.body.splice.apply(self.body,tmp);continue}break}defs=make_node(AST_Var,self,{definitions:defs});hoisted.push(defs)}}self.body=dirs.concat(hoisted,self.body)}return self});OPT(AST_SimpleStatement,function(self,compressor){if(compressor.option("side_effects")){if(!self.body.has_side_effects(compressor)){compressor.warn("Dropping side-effect-free statement [{file}:{line},{col}]",self.start);return make_node(AST_EmptyStatement,self)}}return self});OPT(AST_DWLoop,function(self,compressor){var cond=self.condition.evaluate(compressor);self.condition=cond[0];if(!compressor.option("loops"))return self;if(cond.length>1){if(cond[1]){return make_node(AST_For,self,{body:self.body})}else if(self instanceof AST_While){if(compressor.option("dead_code")){var a=[];extract_declarations_from_unreachable_code(compressor,self.body,a);return make_node(AST_BlockStatement,self,{body:a})}}}return self});function if_break_in_loop(self,compressor){function drop_it(rest){rest=as_statement_array(rest);if(self.body instanceof AST_BlockStatement){self.body=self.body.clone();self.body.body=rest.concat(self.body.body.slice(1));self.body=self.body.transform(compressor)}else{self.body=make_node(AST_BlockStatement,self.body,{body:rest}).transform(compressor)}if_break_in_loop(self,compressor)}var first=self.body instanceof AST_BlockStatement?self.body.body[0]:self.body;if(first instanceof AST_If){if(first.body instanceof AST_Break&&compressor.loopcontrol_target(first.body.label)===self){if(self.condition){self.condition=make_node(AST_Binary,self.condition,{left:self.condition,operator:"&&",right:first.condition.negate(compressor)})}else{self.condition=first.condition.negate(compressor)}drop_it(first.alternative)}else if(first.alternative instanceof AST_Break&&compressor.loopcontrol_target(first.alternative.label)===self){if(self.condition){self.condition=make_node(AST_Binary,self.condition,{left:self.condition,operator:"&&",right:first.condition})}else{self.condition=first.condition}drop_it(first.body)}}}OPT(AST_While,function(self,compressor){if(!compressor.option("loops"))return self;self=AST_DWLoop.prototype.optimize.call(self,compressor);if(self instanceof AST_While){if_break_in_loop(self,compressor);self=make_node(AST_For,self,self).transform(compressor)}return self});OPT(AST_For,function(self,compressor){var cond=self.condition;if(cond){cond=cond.evaluate(compressor);self.condition=cond[0]}if(!compressor.option("loops"))return self;if(cond){if(cond.length>1&&!cond[1]){if(compressor.option("dead_code")){var a=[];if(self.init instanceof AST_Statement){a.push(self.init)}else if(self.init){a.push(make_node(AST_SimpleStatement,self.init,{body:self.init}))}extract_declarations_from_unreachable_code(compressor,self.body,a);return make_node(AST_BlockStatement,self,{body:a})}}}if_break_in_loop(self,compressor);return self});OPT(AST_If,function(self,compressor){if(!compressor.option("conditionals"))return self;var cond=self.condition.evaluate(compressor);self.condition=cond[0];if(cond.length>1){if(cond[1]){compressor.warn("Condition always true [{file}:{line},{col}]",self.condition.start);if(compressor.option("dead_code")){var a=[];if(self.alternative){extract_declarations_from_unreachable_code(compressor,self.alternative,a)}a.push(self.body);return make_node(AST_BlockStatement,self,{body:a}).transform(compressor)}}else{compressor.warn("Condition always false [{file}:{line},{col}]",self.condition.start);if(compressor.option("dead_code")){var a=[];extract_declarations_from_unreachable_code(compressor,self.body,a);if(self.alternative)a.push(self.alternative);return make_node(AST_BlockStatement,self,{body:a}).transform(compressor)}}}if(is_empty(self.alternative))self.alternative=null;var negated=self.condition.negate(compressor);var negated_is_best=best_of(self.condition,negated)===negated;if(self.alternative&&negated_is_best){negated_is_best=false;self.condition=negated;var tmp=self.body;self.body=self.alternative||make_node(AST_EmptyStatement);self.alternative=tmp}if(is_empty(self.body)&&is_empty(self.alternative)){return make_node(AST_SimpleStatement,self.condition,{body:self.condition}).transform(compressor)}if(self.body instanceof AST_SimpleStatement&&self.alternative instanceof AST_SimpleStatement){return make_node(AST_SimpleStatement,self,{body:make_node(AST_Conditional,self,{condition:self.condition,consequent:self.body.body,alternative:self.alternative.body})}).transform(compressor)
+}if(is_empty(self.alternative)&&self.body instanceof AST_SimpleStatement){if(negated_is_best)return make_node(AST_SimpleStatement,self,{body:make_node(AST_Binary,self,{operator:"||",left:negated,right:self.body.body})}).transform(compressor);return make_node(AST_SimpleStatement,self,{body:make_node(AST_Binary,self,{operator:"&&",left:self.condition,right:self.body.body})}).transform(compressor)}if(self.body instanceof AST_EmptyStatement&&self.alternative&&self.alternative instanceof AST_SimpleStatement){return make_node(AST_SimpleStatement,self,{body:make_node(AST_Binary,self,{operator:"||",left:self.condition,right:self.alternative.body})}).transform(compressor)}if(self.body instanceof AST_Exit&&self.alternative instanceof AST_Exit&&self.body.TYPE==self.alternative.TYPE){return make_node(self.body.CTOR,self,{value:make_node(AST_Conditional,self,{condition:self.condition,consequent:self.body.value||make_node(AST_Undefined,self.body).optimize(compressor),alternative:self.alternative.value||make_node(AST_Undefined,self.alternative).optimize(compressor)})}).transform(compressor)}if(self.body instanceof AST_If&&!self.body.alternative&&!self.alternative){self.condition=make_node(AST_Binary,self.condition,{operator:"&&",left:self.condition,right:self.body.condition}).transform(compressor);self.body=self.body.body}if(aborts(self.body)){if(self.alternative){var alt=self.alternative;self.alternative=null;return make_node(AST_BlockStatement,self,{body:[self,alt]}).transform(compressor)}}if(aborts(self.alternative)){var body=self.body;self.body=self.alternative;self.condition=negated_is_best?negated:self.condition.negate(compressor);self.alternative=null;return make_node(AST_BlockStatement,self,{body:[self,body]}).transform(compressor)}return self});OPT(AST_Switch,function(self,compressor){if(self.body.length==0&&compressor.option("conditionals")){return make_node(AST_SimpleStatement,self,{body:self.expression}).transform(compressor)}for(;;){var last_branch=self.body[self.body.length-1];if(last_branch){var stat=last_branch.body[last_branch.body.length-1];if(stat instanceof AST_Break&&loop_body(compressor.loopcontrol_target(stat.label))===self)last_branch.body.pop();if(last_branch instanceof AST_Default&&last_branch.body.length==0){self.body.pop();continue}}break}var exp=self.expression.evaluate(compressor);out:if(exp.length==2)try{self.expression=exp[0];if(!compressor.option("dead_code"))break out;var value=exp[1];var in_if=false;var in_block=false;var started=false;var stopped=false;var ruined=false;var tt=new TreeTransformer(function(node,descend,in_list){if(node instanceof AST_Lambda||node instanceof AST_SimpleStatement){return node}else if(node instanceof AST_Switch&&node===self){node=node.clone();descend(node,this);return ruined?node:make_node(AST_BlockStatement,node,{body:node.body.reduce(function(a,branch){return a.concat(branch.body)},[])}).transform(compressor)}else if(node instanceof AST_If||node instanceof AST_Try){var save=in_if;in_if=!in_block;descend(node,this);in_if=save;return node}else if(node instanceof AST_StatementWithBody||node instanceof AST_Switch){var save=in_block;in_block=true;descend(node,this);in_block=save;return node}else if(node instanceof AST_Break&&this.loopcontrol_target(node.label)===self){if(in_if){ruined=true;return node}if(in_block)return node;stopped=true;return in_list?MAP.skip:make_node(AST_EmptyStatement,node)}else if(node instanceof AST_SwitchBranch&&this.parent()===self){if(stopped)return MAP.skip;if(node instanceof AST_Case){var exp=node.expression.evaluate(compressor);if(exp.length<2){throw self}if(exp[1]===value||started){started=true;if(aborts(node))stopped=true;descend(node,this);return node}return MAP.skip}descend(node,this);return node}});tt.stack=compressor.stack.slice();self=self.transform(tt)}catch(ex){if(ex!==self)throw ex}return self});OPT(AST_Case,function(self,compressor){self.body=tighten_body(self.body,compressor);return self});OPT(AST_Try,function(self,compressor){self.body=tighten_body(self.body,compressor);return self});AST_Definitions.DEFMETHOD("remove_initializers",function(){this.definitions.forEach(function(def){def.value=null})});AST_Definitions.DEFMETHOD("to_assignments",function(){var assignments=this.definitions.reduce(function(a,def){if(def.value){var name=make_node(AST_SymbolRef,def.name,def.name);a.push(make_node(AST_Assign,def,{operator:"=",left:name,right:def.value}))}return a},[]);if(assignments.length==0)return null;return AST_Seq.from_array(assignments)});OPT(AST_Definitions,function(self,compressor){if(self.definitions.length==0)return make_node(AST_EmptyStatement,self);return self});OPT(AST_Function,function(self,compressor){self=AST_Lambda.prototype.optimize.call(self,compressor);if(compressor.option("unused")){if(self.name&&self.name.unreferenced()){self.name=null}}return self});OPT(AST_Call,function(self,compressor){if(compressor.option("unsafe")){var exp=self.expression;if(exp instanceof AST_SymbolRef&&exp.undeclared()){switch(exp.name){case"Array":if(self.args.length!=1){return make_node(AST_Array,self,{elements:self.args}).transform(compressor)}break;case"Object":if(self.args.length==0){return make_node(AST_Object,self,{properties:[]})}break;case"String":if(self.args.length==0)return make_node(AST_String,self,{value:""});if(self.args.length<=1)return make_node(AST_Binary,self,{left:self.args[0],operator:"+",right:make_node(AST_String,self,{value:""})}).transform(compressor);break;case"Number":if(self.args.length==0)return make_node(AST_Number,self,{value:0});if(self.args.length==1)return make_node(AST_UnaryPrefix,self,{expression:self.args[0],operator:"+"}).transform(compressor);case"Boolean":if(self.args.length==0)return make_node(AST_False,self);if(self.args.length==1)return make_node(AST_UnaryPrefix,self,{expression:make_node(AST_UnaryPrefix,null,{expression:self.args[0],operator:"!"}),operator:"!"}).transform(compressor);break;case"Function":if(all(self.args,function(x){return x instanceof AST_String})){try{var code="(function("+self.args.slice(0,-1).map(function(arg){return arg.value}).join(",")+"){"+self.args[self.args.length-1].value+"})()";var ast=parse(code);ast.figure_out_scope({screw_ie8:compressor.option("screw_ie8")});var comp=new Compressor(compressor.options);ast=ast.transform(comp);ast.figure_out_scope({screw_ie8:compressor.option("screw_ie8")});ast.mangle_names();var fun;try{ast.walk(new TreeWalker(function(node){if(node instanceof AST_Lambda){fun=node;throw ast}}))}catch(ex){if(ex!==ast)throw ex}if(!fun)return self;var args=fun.argnames.map(function(arg,i){return make_node(AST_String,self.args[i],{value:arg.print_to_string()})});var code=OutputStream();AST_BlockStatement.prototype._codegen.call(fun,fun,code);code=code.toString().replace(/^\{|\}$/g,"");args.push(make_node(AST_String,self.args[self.args.length-1],{value:code}));self.args=args;return self}catch(ex){if(ex instanceof JS_Parse_Error){compressor.warn("Error parsing code passed to new Function [{file}:{line},{col}]",self.args[self.args.length-1].start);compressor.warn(ex.toString())}else{console.log(ex);throw ex}}}break}}else if(exp instanceof AST_Dot&&exp.property=="toString"&&self.args.length==0){return make_node(AST_Binary,self,{left:make_node(AST_String,self,{value:""}),operator:"+",right:exp.expression}).transform(compressor)}else if(exp instanceof AST_Dot&&exp.expression instanceof AST_Array&&exp.property=="join")EXIT:{var separator=self.args.length==0?",":self.args[0].evaluate(compressor)[1];if(separator==null)break EXIT;var elements=exp.expression.elements.reduce(function(a,el){el=el.evaluate(compressor);if(a.length==0||el.length==1){a.push(el)}else{var last=a[a.length-1];if(last.length==2){var val=""+last[1]+separator+el[1];a[a.length-1]=[make_node_from_constant(compressor,val,last[0]),val]}else{a.push(el)}}return a},[]);if(elements.length==0)return make_node(AST_String,self,{value:""});if(elements.length==1)return elements[0][0];if(separator==""){var first;if(elements[0][0]instanceof AST_String||elements[1][0]instanceof AST_String){first=elements.shift()[0]}else{first=make_node(AST_String,self,{value:""})}return elements.reduce(function(prev,el){return make_node(AST_Binary,el[0],{operator:"+",left:prev,right:el[0]})},first).transform(compressor)}var node=self.clone();node.expression=node.expression.clone();node.expression.expression=node.expression.expression.clone();node.expression.expression.elements=elements.map(function(el){return el[0]});return best_of(self,node)}}if(compressor.option("side_effects")){if(self.expression instanceof AST_Function&&self.args.length==0&&!AST_Block.prototype.has_side_effects.call(self.expression,compressor)){return make_node(AST_Undefined,self).transform(compressor)}}if(compressor.option("drop_console")){if(self.expression instanceof AST_PropAccess&&self.expression.expression instanceof AST_SymbolRef&&self.expression.expression.name=="console"&&self.expression.expression.undeclared()){return make_node(AST_Undefined,self).transform(compressor)}}return self.evaluate(compressor)[0]});OPT(AST_New,function(self,compressor){if(compressor.option("unsafe")){var exp=self.expression;if(exp instanceof AST_SymbolRef&&exp.undeclared()){switch(exp.name){case"Object":case"RegExp":case"Function":case"Error":case"Array":return make_node(AST_Call,self,self).transform(compressor)}}}return self});OPT(AST_Seq,function(self,compressor){if(!compressor.option("side_effects"))return self;if(!self.car.has_side_effects(compressor)){var p;if(!(self.cdr instanceof AST_SymbolRef&&self.cdr.name=="eval"&&self.cdr.undeclared()&&(p=compressor.parent())instanceof AST_Call&&p.expression===self)){return self.cdr}}if(compressor.option("cascade")){if(self.car instanceof AST_Assign&&!self.car.left.has_side_effects(compressor)){if(self.car.left.equivalent_to(self.cdr)){return self.car}if(self.cdr instanceof AST_Call&&self.cdr.expression.equivalent_to(self.car.left)){self.cdr.expression=self.car;return self.cdr}}if(!self.car.has_side_effects(compressor)&&!self.cdr.has_side_effects(compressor)&&self.car.equivalent_to(self.cdr)){return self.car}}if(self.cdr instanceof AST_UnaryPrefix&&self.cdr.operator=="void"&&!self.cdr.expression.has_side_effects(compressor)){self.cdr.operator=self.car;return self.cdr}if(self.cdr instanceof AST_Undefined){return make_node(AST_UnaryPrefix,self,{operator:"void",expression:self.car})}return self});AST_Unary.DEFMETHOD("lift_sequences",function(compressor){if(compressor.option("sequences")){if(this.expression instanceof AST_Seq){var seq=this.expression;var x=seq.to_array();this.expression=x.pop();x.push(this);seq=AST_Seq.from_array(x).transform(compressor);return seq}}return this});OPT(AST_UnaryPostfix,function(self,compressor){return self.lift_sequences(compressor)});OPT(AST_UnaryPrefix,function(self,compressor){self=self.lift_sequences(compressor);var e=self.expression;if(compressor.option("booleans")&&compressor.in_boolean_context()){switch(self.operator){case"!":if(e instanceof AST_UnaryPrefix&&e.operator=="!"){return e.expression}break;case"typeof":compressor.warn("Boolean expression always true [{file}:{line},{col}]",self.start);return make_node(AST_True,self)}if(e instanceof AST_Binary&&self.operator=="!"){self=best_of(self,e.negate(compressor))}}return self.evaluate(compressor)[0]});function has_side_effects_or_prop_access(node,compressor){var save_pure_getters=compressor.option("pure_getters");compressor.options.pure_getters=false;var ret=node.has_side_effects(compressor);compressor.options.pure_getters=save_pure_getters;return ret}AST_Binary.DEFMETHOD("lift_sequences",function(compressor){if(compressor.option("sequences")){if(this.left instanceof AST_Seq){var seq=this.left;var x=seq.to_array();this.left=x.pop();x.push(this);seq=AST_Seq.from_array(x).transform(compressor);return seq}if(this.right instanceof AST_Seq&&this instanceof AST_Assign&&!has_side_effects_or_prop_access(this.left,compressor)){var seq=this.right;var x=seq.to_array();this.right=x.pop();x.push(this);seq=AST_Seq.from_array(x).transform(compressor);return seq}}return this});var commutativeOperators=makePredicate("== === != !== * & | ^");OPT(AST_Binary,function(self,compressor){var reverse=compressor.has_directive("use asm")?noop:function(op,force){if(force||!(self.left.has_side_effects(compressor)||self.right.has_side_effects(compressor))){if(op)self.operator=op;var tmp=self.left;self.left=self.right;self.right=tmp}};if(commutativeOperators(self.operator)){if(self.right instanceof AST_Constant&&!(self.left instanceof AST_Constant)){if(!(self.left instanceof AST_Binary&&PRECEDENCE[self.left.operator]>=PRECEDENCE[self.operator])){reverse(null,true)}}if(/^[!=]==?$/.test(self.operator)){if(self.left instanceof AST_SymbolRef&&self.right instanceof AST_Conditional){if(self.right.consequent instanceof AST_SymbolRef&&self.right.consequent.definition()===self.left.definition()){if(/^==/.test(self.operator))return self.right.condition;if(/^!=/.test(self.operator))return self.right.condition.negate(compressor)}if(self.right.alternative instanceof AST_SymbolRef&&self.right.alternative.definition()===self.left.definition()){if(/^==/.test(self.operator))return self.right.condition.negate(compressor);if(/^!=/.test(self.operator))return self.right.condition}}if(self.right instanceof AST_SymbolRef&&self.left instanceof AST_Conditional){if(self.left.consequent instanceof AST_SymbolRef&&self.left.consequent.definition()===self.right.definition()){if(/^==/.test(self.operator))return self.left.condition;if(/^!=/.test(self.operator))return self.left.condition.negate(compressor)}if(self.left.alternative instanceof AST_SymbolRef&&self.left.alternative.definition()===self.right.definition()){if(/^==/.test(self.operator))return self.left.condition.negate(compressor);if(/^!=/.test(self.operator))return self.left.condition}}}}self=self.lift_sequences(compressor);if(compressor.option("comparisons"))switch(self.operator){case"===":case"!==":if(self.left.is_string(compressor)&&self.right.is_string(compressor)||self.left.is_boolean()&&self.right.is_boolean()){self.operator=self.operator.substr(0,2)}case"==":case"!=":if(self.left instanceof AST_String&&self.left.value=="undefined"&&self.right instanceof AST_UnaryPrefix&&self.right.operator=="typeof"&&compressor.option("unsafe")){if(!(self.right.expression instanceof AST_SymbolRef)||!self.right.expression.undeclared()){self.right=self.right.expression;self.left=make_node(AST_Undefined,self.left).optimize(compressor);if(self.operator.length==2)self.operator+="="}}break}if(compressor.option("booleans")&&compressor.in_boolean_context())switch(self.operator){case"&&":var ll=self.left.evaluate(compressor);var rr=self.right.evaluate(compressor);if(ll.length>1&&!ll[1]||rr.length>1&&!rr[1]){compressor.warn("Boolean && always false [{file}:{line},{col}]",self.start);return make_node(AST_False,self)}if(ll.length>1&&ll[1]){return rr[0]}if(rr.length>1&&rr[1]){return ll[0]}break;case"||":var ll=self.left.evaluate(compressor);var rr=self.right.evaluate(compressor);if(ll.length>1&&ll[1]||rr.length>1&&rr[1]){compressor.warn("Boolean || always true [{file}:{line},{col}]",self.start);return make_node(AST_True,self)}if(ll.length>1&&!ll[1]){return rr[0]}if(rr.length>1&&!rr[1]){return ll[0]}break;case"+":var ll=self.left.evaluate(compressor);var rr=self.right.evaluate(compressor);if(ll.length>1&&ll[0]instanceof AST_String&&ll[1]||rr.length>1&&rr[0]instanceof AST_String&&rr[1]){compressor.warn("+ in boolean context always true [{file}:{line},{col}]",self.start);return make_node(AST_True,self)}break}if(compressor.option("comparisons")){if(!(compressor.parent()instanceof AST_Binary)||compressor.parent()instanceof AST_Assign){var negated=make_node(AST_UnaryPrefix,self,{operator:"!",expression:self.negate(compressor)});self=best_of(self,negated)}switch(self.operator){case"<":reverse(">");break;case"<=":reverse(">=");break}}if(self.operator=="+"&&self.right instanceof AST_String&&self.right.getValue()===""&&self.left instanceof AST_Binary&&self.left.operator=="+"&&self.left.is_string(compressor)){return self.left}if(compressor.option("evaluate")){if(self.operator=="+"){if(self.left instanceof AST_Constant&&self.right instanceof AST_Binary&&self.right.operator=="+"&&self.right.left instanceof AST_Constant&&self.right.is_string(compressor)){self=make_node(AST_Binary,self,{operator:"+",left:make_node(AST_String,null,{value:""+self.left.getValue()+self.right.left.getValue(),start:self.left.start,end:self.right.left.end}),right:self.right.right})}if(self.right instanceof AST_Constant&&self.left instanceof AST_Binary&&self.left.operator=="+"&&self.left.right instanceof AST_Constant&&self.left.is_string(compressor)){self=make_node(AST_Binary,self,{operator:"+",left:self.left.left,right:make_node(AST_String,null,{value:""+self.left.right.getValue()+self.right.getValue(),start:self.left.right.start,end:self.right.end})})}if(self.left instanceof AST_Binary&&self.left.operator=="+"&&self.left.is_string(compressor)&&self.left.right instanceof AST_Constant&&self.right instanceof AST_Binary&&self.right.operator=="+"&&self.right.left instanceof AST_Constant&&self.right.is_string(compressor)){self=make_node(AST_Binary,self,{operator:"+",left:make_node(AST_Binary,self.left,{operator:"+",left:self.left.left,right:make_node(AST_String,null,{value:""+self.left.right.getValue()+self.right.left.getValue(),start:self.left.right.start,end:self.right.left.end})}),right:self.right.right})}}}if(self.right instanceof AST_Binary&&self.right.operator==self.operator&&(self.operator=="*"||self.operator=="&&"||self.operator=="||")){self.left=make_node(AST_Binary,self.left,{operator:self.operator,left:self.left,right:self.right.left});self.right=self.right.right;return self.transform(compressor)}return self.evaluate(compressor)[0]});OPT(AST_SymbolRef,function(self,compressor){if(self.undeclared()){var defines=compressor.option("global_defs");if(defines&&defines.hasOwnProperty(self.name)){return make_node_from_constant(compressor,defines[self.name],self)}switch(self.name){case"undefined":return make_node(AST_Undefined,self);case"NaN":return make_node(AST_NaN,self);case"Infinity":return make_node(AST_Infinity,self)}}return self});OPT(AST_Undefined,function(self,compressor){if(compressor.option("unsafe")){var scope=compressor.find_parent(AST_Scope);var undef=scope.find_variable("undefined");if(undef){var ref=make_node(AST_SymbolRef,self,{name:"undefined",scope:scope,thedef:undef});ref.reference();return ref}}return self});var ASSIGN_OPS=["+","-","/","*","%",">>","<<",">>>","|","^","&"];OPT(AST_Assign,function(self,compressor){self=self.lift_sequences(compressor);if(self.operator=="="&&self.left instanceof AST_SymbolRef&&self.right instanceof AST_Binary&&self.right.left instanceof AST_SymbolRef&&self.right.left.name==self.left.name&&member(self.right.operator,ASSIGN_OPS)){self.operator=self.right.operator+"=";self.right=self.right.right}return self});OPT(AST_Conditional,function(self,compressor){if(!compressor.option("conditionals"))return self;if(self.condition instanceof AST_Seq){var car=self.condition.car;self.condition=self.condition.cdr;return AST_Seq.cons(car,self)}var cond=self.condition.evaluate(compressor);if(cond.length>1){if(cond[1]){compressor.warn("Condition always true [{file}:{line},{col}]",self.start);return self.consequent}else{compressor.warn("Condition always false [{file}:{line},{col}]",self.start);return self.alternative}}var negated=cond[0].negate(compressor);if(best_of(cond[0],negated)===negated){self=make_node(AST_Conditional,self,{condition:negated,consequent:self.alternative,alternative:self.consequent})}var consequent=self.consequent;var alternative=self.alternative;if(consequent instanceof AST_Assign&&alternative instanceof AST_Assign&&consequent.operator==alternative.operator&&consequent.left.equivalent_to(alternative.left)){return make_node(AST_Assign,self,{operator:consequent.operator,left:consequent.left,right:make_node(AST_Conditional,self,{condition:self.condition,consequent:consequent.right,alternative:alternative.right})})}if(consequent instanceof AST_Call&&alternative.TYPE===consequent.TYPE&&consequent.args.length==alternative.args.length&&consequent.expression.equivalent_to(alternative.expression)){if(consequent.args.length==0){return make_node(AST_Seq,self,{car:self.condition,cdr:consequent})}if(consequent.args.length==1){consequent.args[0]=make_node(AST_Conditional,self,{condition:self.condition,consequent:consequent.args[0],alternative:alternative.args[0]});return consequent}}if(consequent instanceof AST_Conditional&&consequent.alternative.equivalent_to(alternative)){return make_node(AST_Conditional,self,{condition:make_node(AST_Binary,self,{left:self.condition,operator:"&&",right:consequent.condition}),consequent:consequent.consequent,alternative:alternative})}if(consequent instanceof AST_Constant&&alternative instanceof AST_Constant&&consequent.equivalent_to(alternative)){if(self.condition.has_side_effects(compressor)){return AST_Seq.from_array([self.condition,make_node_from_constant(compressor,consequent.value,self)])}else{return make_node_from_constant(compressor,consequent.value,self)}}return self});OPT(AST_Boolean,function(self,compressor){if(compressor.option("booleans")){var p=compressor.parent();if(p instanceof AST_Binary&&(p.operator=="=="||p.operator=="!=")){compressor.warn("Non-strict equality against boolean: {operator} {value} [{file}:{line},{col}]",{operator:p.operator,value:self.value,file:p.start.file,line:p.start.line,col:p.start.col});return make_node(AST_Number,self,{value:+self.value})}return make_node(AST_UnaryPrefix,self,{operator:"!",expression:make_node(AST_Number,self,{value:1-self.value})})}return self});OPT(AST_Sub,function(self,compressor){var prop=self.property;if(prop instanceof AST_String&&compressor.option("properties")){prop=prop.getValue();if(RESERVED_WORDS(prop)?compressor.option("screw_ie8"):is_identifier_string(prop)){return make_node(AST_Dot,self,{expression:self.expression,property:prop}).optimize(compressor)}var v=parseFloat(prop);if(!isNaN(v)&&v.toString()==prop){self.property=make_node(AST_Number,self.property,{value:v})}}return self});OPT(AST_Dot,function(self,compressor){var prop=self.property;if(RESERVED_WORDS(prop)&&!compressor.option("screw_ie8")){return make_node(AST_Sub,self,{expression:self.expression,property:make_node(AST_String,self,{value:prop})}).optimize(compressor)}return self.evaluate(compressor)[0]});function literals_in_boolean_context(self,compressor){if(compressor.option("booleans")&&compressor.in_boolean_context()){return make_node(AST_True,self)}return self}OPT(AST_Array,literals_in_boolean_context);OPT(AST_Object,literals_in_boolean_context);OPT(AST_RegExp,literals_in_boolean_context)})();/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";function SourceMap(options){options=defaults(options,{file:null,root:null,orig:null,orig_line_diff:0,dest_line_diff:0});var generator=new MOZ_SourceMap.SourceMapGenerator({file:options.file,sourceRoot:options.root});var orig_map=options.orig&&new MOZ_SourceMap.SourceMapConsumer(options.orig);function add(source,gen_line,gen_col,orig_line,orig_col,name){if(orig_map){var info=orig_map.originalPositionFor({line:orig_line,column:orig_col});if(info.source===null){return}source=info.source;orig_line=info.line;orig_col=info.column;name=info.name||name}generator.addMapping({generated:{line:gen_line+options.dest_line_diff,column:gen_col},original:{line:orig_line+options.orig_line_diff,column:orig_col},source:source,name:name})}return{add:add,get:function(){return generator},toString:function(){return generator.toString()}}}/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+"use strict";(function(){var MOZ_TO_ME={ExpressionStatement:function(M){var expr=M.expression;if(expr.type==="Literal"&&typeof expr.value==="string"){return new AST_Directive({start:my_start_token(M),end:my_end_token(M),value:expr.value})}return new AST_SimpleStatement({start:my_start_token(M),end:my_end_token(M),body:from_moz(expr)})},TryStatement:function(M){var handlers=M.handlers||[M.handler];if(handlers.length>1||M.guardedHandlers&&M.guardedHandlers.length){throw new Error("Multiple catch clauses are not supported.")}return new AST_Try({start:my_start_token(M),end:my_end_token(M),body:from_moz(M.block).body,bcatch:from_moz(handlers[0]),bfinally:M.finalizer?new AST_Finally(from_moz(M.finalizer)):null})},Property:function(M){var key=M.key;var name=key.type=="Identifier"?key.name:key.value;var args={start:my_start_token(key),end:my_end_token(M.value),key:name,value:from_moz(M.value)};switch(M.kind){case"init":return new AST_ObjectKeyVal(args);case"set":args.value.name=from_moz(key);return new AST_ObjectSetter(args);case"get":args.value.name=from_moz(key);return new AST_ObjectGetter(args)}},ObjectExpression:function(M){return new AST_Object({start:my_start_token(M),end:my_end_token(M),properties:M.properties.map(function(prop){prop.type="Property";return from_moz(prop)})})},SequenceExpression:function(M){return AST_Seq.from_array(M.expressions.map(from_moz))},MemberExpression:function(M){return new(M.computed?AST_Sub:AST_Dot)({start:my_start_token(M),end:my_end_token(M),property:M.computed?from_moz(M.property):M.property.name,expression:from_moz(M.object)})},SwitchCase:function(M){return new(M.test?AST_Case:AST_Default)({start:my_start_token(M),end:my_end_token(M),expression:from_moz(M.test),body:M.consequent.map(from_moz)})},VariableDeclaration:function(M){return new(M.kind==="const"?AST_Const:AST_Var)({start:my_start_token(M),end:my_end_token(M),definitions:M.declarations.map(from_moz)})},Literal:function(M){var val=M.value,args={start:my_start_token(M),end:my_end_token(M)};if(val===null)return new AST_Null(args);switch(typeof val){case"string":args.value=val;return new AST_String(args);case"number":args.value=val;return new AST_Number(args);case"boolean":return new(val?AST_True:AST_False)(args);default:args.value=val;return new AST_RegExp(args)}},Identifier:function(M){var p=FROM_MOZ_STACK[FROM_MOZ_STACK.length-2];return new(p.type=="LabeledStatement"?AST_Label:p.type=="VariableDeclarator"&&p.id===M?p.kind=="const"?AST_SymbolConst:AST_SymbolVar:p.type=="FunctionExpression"?p.id===M?AST_SymbolLambda:AST_SymbolFunarg:p.type=="FunctionDeclaration"?p.id===M?AST_SymbolDefun:AST_SymbolFunarg:p.type=="CatchClause"?AST_SymbolCatch:p.type=="BreakStatement"||p.type=="ContinueStatement"?AST_LabelRef:AST_SymbolRef)({start:my_start_token(M),end:my_end_token(M),name:M.name})}};MOZ_TO_ME.UpdateExpression=MOZ_TO_ME.UnaryExpression=function To_Moz_Unary(M){var prefix="prefix"in M?M.prefix:M.type=="UnaryExpression"?true:false;return new(prefix?AST_UnaryPrefix:AST_UnaryPostfix)({start:my_start_token(M),end:my_end_token(M),operator:M.operator,expression:from_moz(M.argument)})};map("Program",AST_Toplevel,"body@body");map("EmptyStatement",AST_EmptyStatement);map("BlockStatement",AST_BlockStatement,"body@body");map("IfStatement",AST_If,"test>condition, consequent>body, alternate>alternative");map("LabeledStatement",AST_LabeledStatement,"label>label, body>body");map("BreakStatement",AST_Break,"label>label");map("ContinueStatement",AST_Continue,"label>label");map("WithStatement",AST_With,"object>expression, body>body");map("SwitchStatement",AST_Switch,"discriminant>expression, cases@body");map("ReturnStatement",AST_Return,"argument>value");map("ThrowStatement",AST_Throw,"argument>value");map("WhileStatement",AST_While,"test>condition, body>body");map("DoWhileStatement",AST_Do,"test>condition, body>body");map("ForStatement",AST_For,"init>init, test>condition, update>step, body>body");map("ForInStatement",AST_ForIn,"left>init, right>object, body>body");map("DebuggerStatement",AST_Debugger);map("FunctionDeclaration",AST_Defun,"id>name, params@argnames, body%body");map("VariableDeclarator",AST_VarDef,"id>name, init>value");map("CatchClause",AST_Catch,"param>argname, body%body");map("ThisExpression",AST_This);map("ArrayExpression",AST_Array,"elements@elements");map("FunctionExpression",AST_Function,"id>name, params@argnames, body%body");map("BinaryExpression",AST_Binary,"operator=operator, left>left, right>right");map("LogicalExpression",AST_Binary,"operator=operator, left>left, right>right");map("AssignmentExpression",AST_Assign,"operator=operator, left>left, right>right");map("ConditionalExpression",AST_Conditional,"test>condition, consequent>consequent, alternate>alternative");map("NewExpression",AST_New,"callee>expression, arguments@args");map("CallExpression",AST_Call,"callee>expression, arguments@args");def_to_moz(AST_Directive,function To_Moz_Directive(M){return{type:"ExpressionStatement",expression:{type:"Literal",value:M.value}}});def_to_moz(AST_SimpleStatement,function To_Moz_ExpressionStatement(M){return{type:"ExpressionStatement",expression:to_moz(M.body)}});def_to_moz(AST_SwitchBranch,function To_Moz_SwitchCase(M){return{type:"SwitchCase",test:to_moz(M.expression),consequent:M.body.map(to_moz)}});def_to_moz(AST_Try,function To_Moz_TryStatement(M){return{type:"TryStatement",block:to_moz_block(M),handler:to_moz(M.bcatch),guardedHandlers:[],finalizer:to_moz(M.bfinally)}});def_to_moz(AST_Catch,function To_Moz_CatchClause(M){return{type:"CatchClause",param:to_moz(M.argname),guard:null,body:to_moz_block(M)}});def_to_moz(AST_Definitions,function To_Moz_VariableDeclaration(M){return{type:"VariableDeclaration",kind:M instanceof AST_Const?"const":"var",declarations:M.definitions.map(to_moz)}});def_to_moz(AST_Seq,function To_Moz_SequenceExpression(M){return{type:"SequenceExpression",expressions:M.to_array().map(to_moz)}});def_to_moz(AST_PropAccess,function To_Moz_MemberExpression(M){var isComputed=M instanceof AST_Sub;return{type:"MemberExpression",object:to_moz(M.expression),computed:isComputed,property:isComputed?to_moz(M.property):{type:"Identifier",name:M.property}}});def_to_moz(AST_Unary,function To_Moz_Unary(M){return{type:M.operator=="++"||M.operator=="--"?"UpdateExpression":"UnaryExpression",operator:M.operator,prefix:M instanceof AST_UnaryPrefix,argument:to_moz(M.expression)}});def_to_moz(AST_Binary,function To_Moz_BinaryExpression(M){return{type:M.operator=="&&"||M.operator=="||"?"LogicalExpression":"BinaryExpression",left:to_moz(M.left),operator:M.operator,right:to_moz(M.right)}});def_to_moz(AST_Object,function To_Moz_ObjectExpression(M){return{type:"ObjectExpression",properties:M.properties.map(to_moz)}});def_to_moz(AST_ObjectProperty,function To_Moz_Property(M){var key=is_identifier(M.key)?{type:"Identifier",name:M.key}:{type:"Literal",value:M.key};var kind;if(M instanceof AST_ObjectKeyVal){kind="init"}else if(M instanceof AST_ObjectGetter){kind="get"}else if(M instanceof AST_ObjectSetter){kind="set"}return{type:"Property",kind:kind,key:key,value:to_moz(M.value)}});def_to_moz(AST_Symbol,function To_Moz_Identifier(M){var def=M.definition();return{type:"Identifier",name:def?def.mangled_name||def.name:M.name}});def_to_moz(AST_Constant,function To_Moz_Literal(M){var value=M.value;if(typeof value==="number"&&(value<0||value===0&&1/value<0)){return{type:"UnaryExpression",operator:"-",prefix:true,argument:{type:"Literal",value:-value}}}return{type:"Literal",value:value}});def_to_moz(AST_Atom,function To_Moz_Atom(M){return{type:"Identifier",name:String(M.value)}});AST_Boolean.DEFMETHOD("to_mozilla_ast",AST_Constant.prototype.to_mozilla_ast);AST_Null.DEFMETHOD("to_mozilla_ast",AST_Constant.prototype.to_mozilla_ast);AST_Hole.DEFMETHOD("to_mozilla_ast",function To_Moz_ArrayHole(){return null});AST_Block.DEFMETHOD("to_mozilla_ast",AST_BlockStatement.prototype.to_mozilla_ast);AST_Lambda.DEFMETHOD("to_mozilla_ast",AST_Function.prototype.to_mozilla_ast);function my_start_token(moznode){var loc=moznode.loc;var range=moznode.range;return new AST_Token({file:loc&&loc.source,line:loc&&loc.start.line,col:loc&&loc.start.column,pos:range?range[0]:moznode.start,endpos:range?range[0]:moznode.start})}function my_end_token(moznode){var loc=moznode.loc;var range=moznode.range;return new AST_Token({file:loc&&loc.source,line:loc&&loc.end.line,col:loc&&loc.end.column,pos:range?range[1]:moznode.end,endpos:range?range[1]:moznode.end})}function map(moztype,mytype,propmap){var moz_to_me="function From_Moz_"+moztype+"(M){\n";moz_to_me+="return new "+mytype.name+"({\n"+"start: my_start_token(M),\n"+"end: my_end_token(M)";var me_to_moz="function To_Moz_"+moztype+"(M){\n";me_to_moz+="return {\n"+"type: "+JSON.stringify(moztype);if(propmap)propmap.split(/\s*,\s*/).forEach(function(prop){var m=/([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);if(!m)throw new Error("Can't understand property map: "+prop);var moz=m[1],how=m[2],my=m[3];moz_to_me+=",\n"+my+": ";me_to_moz+=",\n"+moz+": ";switch(how){case"@":moz_to_me+="M."+moz+".map(from_moz)";me_to_moz+="M."+my+".map(to_moz)";break;case">":moz_to_me+="from_moz(M."+moz+")";me_to_moz+="to_moz(M."+my+")";break;case"=":moz_to_me+="M."+moz;me_to_moz+="M."+my;break;case"%":moz_to_me+="from_moz(M."+moz+").body";me_to_moz+="to_moz_block(M)";break;default:throw new Error("Can't understand operator in propmap: "+prop)}});moz_to_me+="\n})\n}";me_to_moz+="\n}\n}";moz_to_me=new Function("my_start_token","my_end_token","from_moz","return("+moz_to_me+")")(my_start_token,my_end_token,from_moz);me_to_moz=new Function("to_moz","to_moz_block","return("+me_to_moz+")")(to_moz,to_moz_block);MOZ_TO_ME[moztype]=moz_to_me;def_to_moz(mytype,me_to_moz)}var FROM_MOZ_STACK=null;function from_moz(node){FROM_MOZ_STACK.push(node);var ret=node!=null?MOZ_TO_ME[node.type](node):null;FROM_MOZ_STACK.pop();return ret}AST_Node.from_mozilla_ast=function(node){var save_stack=FROM_MOZ_STACK;FROM_MOZ_STACK=[];var ast=from_moz(node);FROM_MOZ_STACK=save_stack;return ast};function moz_sub_loc(token){return token.line?{line:token.line,column:token.col}:null}function set_moz_loc(mynode,moznode){var start=mynode.start;var end=mynode.end;if(start.pos!=null&&end.pos!=null){moznode.range=[start.pos,end.pos]}if(start.line){moznode.loc={start:moz_sub_loc(start),end:moz_sub_loc(end)};if(start.file){moznode.loc.source=start.file}}return moznode}function def_to_moz(mytype,handler){mytype.DEFMETHOD("to_mozilla_ast",function(){return set_moz_loc(this,handler(this))})}function to_moz(node){return node!=null?node.to_mozilla_ast():null}function to_moz_block(node){return{type:"BlockStatement",body:node.body.map(to_moz)}}})();exports["array_to_hash"]=array_to_hash;exports["slice"]=slice;exports["characters"]=characters;exports["member"]=member;exports["find_if"]=find_if;exports["repeat_string"]=repeat_string;exports["DefaultsError"]=DefaultsError;exports["defaults"]=defaults;exports["merge"]=merge;exports["noop"]=noop;exports["MAP"]=MAP;exports["push_uniq"]=push_uniq;exports["string_template"]=string_template;exports["remove"]=remove;exports["mergeSort"]=mergeSort;exports["set_difference"]=set_difference;exports["set_intersection"]=set_intersection;exports["makePredicate"]=makePredicate;exports["all"]=all;exports["Dictionary"]=Dictionary;exports["DEFNODE"]=DEFNODE;exports["AST_Token"]=AST_Token;exports["AST_Node"]=AST_Node;exports["AST_Statement"]=AST_Statement;exports["AST_Debugger"]=AST_Debugger;exports["AST_Directive"]=AST_Directive;exports["AST_SimpleStatement"]=AST_SimpleStatement;exports["walk_body"]=walk_body;exports["AST_Block"]=AST_Block;exports["AST_BlockStatement"]=AST_BlockStatement;exports["AST_EmptyStatement"]=AST_EmptyStatement;exports["AST_StatementWithBody"]=AST_StatementWithBody;exports["AST_LabeledStatement"]=AST_LabeledStatement;exports["AST_IterationStatement"]=AST_IterationStatement;exports["AST_DWLoop"]=AST_DWLoop;exports["AST_Do"]=AST_Do;exports["AST_While"]=AST_While;exports["AST_For"]=AST_For;exports["AST_ForIn"]=AST_ForIn;exports["AST_With"]=AST_With;exports["AST_Scope"]=AST_Scope;exports["AST_Toplevel"]=AST_Toplevel;exports["AST_Lambda"]=AST_Lambda;exports["AST_Accessor"]=AST_Accessor;exports["AST_Function"]=AST_Function;exports["AST_Defun"]=AST_Defun;exports["AST_Jump"]=AST_Jump;exports["AST_Exit"]=AST_Exit;exports["AST_Return"]=AST_Return;exports["AST_Throw"]=AST_Throw;exports["AST_LoopControl"]=AST_LoopControl;exports["AST_Break"]=AST_Break;exports["AST_Continue"]=AST_Continue;exports["AST_If"]=AST_If;exports["AST_Switch"]=AST_Switch;exports["AST_SwitchBranch"]=AST_SwitchBranch;exports["AST_Default"]=AST_Default;exports["AST_Case"]=AST_Case;exports["AST_Try"]=AST_Try;exports["AST_Catch"]=AST_Catch;exports["AST_Finally"]=AST_Finally;exports["AST_Definitions"]=AST_Definitions;exports["AST_Var"]=AST_Var;exports["AST_Const"]=AST_Const;exports["AST_VarDef"]=AST_VarDef;exports["AST_Call"]=AST_Call;exports["AST_New"]=AST_New;exports["AST_Seq"]=AST_Seq;exports["AST_PropAccess"]=AST_PropAccess;exports["AST_Dot"]=AST_Dot;exports["AST_Sub"]=AST_Sub;exports["AST_Unary"]=AST_Unary;exports["AST_UnaryPrefix"]=AST_UnaryPrefix;exports["AST_UnaryPostfix"]=AST_UnaryPostfix;exports["AST_Binary"]=AST_Binary;exports["AST_Conditional"]=AST_Conditional;exports["AST_Assign"]=AST_Assign;exports["AST_Array"]=AST_Array;exports["AST_Object"]=AST_Object;exports["AST_ObjectProperty"]=AST_ObjectProperty;exports["AST_ObjectKeyVal"]=AST_ObjectKeyVal;exports["AST_ObjectSetter"]=AST_ObjectSetter;exports["AST_ObjectGetter"]=AST_ObjectGetter;exports["AST_Symbol"]=AST_Symbol;exports["AST_SymbolAccessor"]=AST_SymbolAccessor;exports["AST_SymbolDeclaration"]=AST_SymbolDeclaration;exports["AST_SymbolVar"]=AST_SymbolVar;exports["AST_SymbolConst"]=AST_SymbolConst;exports["AST_SymbolFunarg"]=AST_SymbolFunarg;exports["AST_SymbolDefun"]=AST_SymbolDefun;exports["AST_SymbolLambda"]=AST_SymbolLambda;exports["AST_SymbolCatch"]=AST_SymbolCatch;exports["AST_Label"]=AST_Label;exports["AST_SymbolRef"]=AST_SymbolRef;exports["AST_LabelRef"]=AST_LabelRef;exports["AST_This"]=AST_This;exports["AST_Constant"]=AST_Constant;exports["AST_String"]=AST_String;exports["AST_Number"]=AST_Number;exports["AST_RegExp"]=AST_RegExp;exports["AST_Atom"]=AST_Atom;exports["AST_Null"]=AST_Null;exports["AST_NaN"]=AST_NaN;exports["AST_Undefined"]=AST_Undefined;exports["AST_Hole"]=AST_Hole;exports["AST_Infinity"]=AST_Infinity;exports["AST_Boolean"]=AST_Boolean;exports["AST_False"]=AST_False;exports["AST_True"]=AST_True;exports["TreeWalker"]=TreeWalker;exports["KEYWORDS"]=KEYWORDS;exports["KEYWORDS_ATOM"]=KEYWORDS_ATOM;exports["RESERVED_WORDS"]=RESERVED_WORDS;exports["KEYWORDS_BEFORE_EXPRESSION"]=KEYWORDS_BEFORE_EXPRESSION;exports["OPERATOR_CHARS"]=OPERATOR_CHARS;exports["RE_HEX_NUMBER"]=RE_HEX_NUMBER;exports["RE_OCT_NUMBER"]=RE_OCT_NUMBER;exports["RE_DEC_NUMBER"]=RE_DEC_NUMBER;exports["OPERATORS"]=OPERATORS;exports["WHITESPACE_CHARS"]=WHITESPACE_CHARS;exports["PUNC_BEFORE_EXPRESSION"]=PUNC_BEFORE_EXPRESSION;exports["PUNC_CHARS"]=PUNC_CHARS;exports["REGEXP_MODIFIERS"]=REGEXP_MODIFIERS;exports["UNICODE"]=UNICODE;exports["is_letter"]=is_letter;exports["is_digit"]=is_digit;exports["is_alphanumeric_char"]=is_alphanumeric_char;exports["is_unicode_combining_mark"]=is_unicode_combining_mark;exports["is_unicode_connector_punctuation"]=is_unicode_connector_punctuation;exports["is_identifier"]=is_identifier;exports["is_identifier_start"]=is_identifier_start;exports["is_identifier_char"]=is_identifier_char;exports["is_identifier_string"]=is_identifier_string;exports["parse_js_number"]=parse_js_number;exports["JS_Parse_Error"]=JS_Parse_Error;exports["js_error"]=js_error;exports["is_token"]=is_token;exports["EX_EOF"]=EX_EOF;exports["tokenizer"]=tokenizer;exports["UNARY_PREFIX"]=UNARY_PREFIX;exports["UNARY_POSTFIX"]=UNARY_POSTFIX;exports["ASSIGNMENT"]=ASSIGNMENT;exports["PRECEDENCE"]=PRECEDENCE;exports["STATEMENTS_WITH_LABELS"]=STATEMENTS_WITH_LABELS;exports["ATOMIC_START_TOKEN"]=ATOMIC_START_TOKEN;exports["parse"]=parse;exports["TreeTransformer"]=TreeTransformer;exports["SymbolDef"]=SymbolDef;exports["base54"]=base54;exports["OutputStream"]=OutputStream;exports["Compressor"]=Compressor;exports["SourceMap"]=SourceMap})({},function(){return this}());
diff --git a/test/test_execjs.rb b/test/test_execjs.rb
index 20b8a53..1c40a6a 100644
--- a/test/test_execjs.rb
+++ b/test/test_execjs.rb
@@ -288,9 +288,39 @@ class TestExecJS < Test
     end
   end
 
+  def test_babel
+    assert source = File.read(File.expand_path("../fixtures/babel.js", __FILE__))
+    source = <<-JS
+      var self = this;
+      #{source}
+      babel.eval = function(code) {
+        return eval(babel.transform(code)["code"]);
+      }
+    JS
+    context = ExecJS.compile(source)
+    assert_equal 64, context.call("babel.eval", "((x) => x * x)(8)")
+  end
+
   def test_coffeescript
     assert source = File.read(File.expand_path("../fixtures/coffee-script.js", __FILE__))
     context = ExecJS.compile(source)
     assert_equal 64, context.call("CoffeeScript.eval", "((x) -> x * x)(8)")
   end
+
+  def test_uglify
+    assert source = File.read(File.expand_path("../fixtures/uglify.js", __FILE__))
+    source = <<-JS
+      #{source}
+
+      function uglify(source) {
+        var ast = UglifyJS.parse(source);
+        var stream = UglifyJS.OutputStream();
+        ast.print(stream);
+        return stream.toString();
+      }
+    JS
+    context = ExecJS.compile(source)
+    assert_equal "function foo(bar){return bar}",
+      context.call("uglify", "function foo(bar) {\n  return bar;\n}")
+  end
 end